From b52c22dd39aff6fcdb797bd9f8ad7e77c5c1780f Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Wed, 24 Oct 2018 19:31:20 +0900
Subject: [PATCH 001/181] Travis: Remove node v9 and add node v10

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 1acc2fbd..24c0b17f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,7 +2,7 @@ language: node_js
 # Follow https://github.com/nodejs/LTS to decide when to remove a version
 node_js:
 - stable
-- 9
+- 10
 - 8
 # 6.13 and 6.14 causing unreasonable errors in SymbolDefinition.initialize.
 # https://travis-ci.org/paperjs/paper.js/jobs/434854796

From 97b87e383662e97a7a29e7b9aa9d03d7c8d48fd1 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Sun, 4 Nov 2018 12:31:06 +0100
Subject: [PATCH 002/181] Fix crashing build disabling node v11

Node v11 is temporarily disabled from ci build until a bug is fixed in
resemblejs package.
---
 .travis.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 24c0b17f..c0903c5d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,9 @@
 language: node_js
 # Follow https://github.com/nodejs/LTS to decide when to remove a version
 node_js:
-- stable
+# Stable version is temporarily disabled due to a bug in resemblejs package with
+# node v11 (https://github.com/orgs/paperjs/teams/contributors/discussions/8).
+# - stable
 - 10
 - 8
 # 6.13 and 6.14 causing unreasonable errors in SymbolDefinition.initialize.

From c44f56d52fa21fd56e56a36721b45eaa18018e5d Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Sun, 4 Nov 2018 13:41:35 +0100
Subject: [PATCH 003/181] Fix Rectangle documentation

Add missing return values in Rectangle boolean operations.
Closes #1399
---
 src/basic/Rectangle.js | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index 0a2cae29..b3478df3 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -772,6 +772,8 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * Rectangle#contains(point)} returns `false` for that point.
      *
      * @param {Point} point
+     * @return {Rectangle} the smallest rectangle that contains both the
+     * original rectangle and the specified point
      */
     include: function(/* point */) {
         var point = Point.read(arguments);
@@ -783,17 +785,18 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
     },
 
     /**
-     * Expands the rectangle by the specified amount in horizontal and
-     * vertical directions.
+     * Returns a new rectangle expanded by the specified amount in horizontal
+     * and vertical directions.
      *
      * @name Rectangle#expand
      * @function
      * @param {Number|Size|Point} amount the amount to expand the rectangle in
      * both directions
+     * @return {Rectangle} the expanded rectangle
      */
     /**
-     * Expands the rectangle by the specified amounts in horizontal and
-     * vertical directions.
+     * Returns a new rectangle expanded by the specified amounts in horizontal
+     * and vertical directions.
      *
      * @name Rectangle#expand
      * @function
@@ -801,6 +804,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * direction
      * @param {Number} ver the amount to expand the rectangle in vertical
      * direction
+     * @return {Rectangle} the expanded rectangle
      */
     expand: function(/* amount */) {
         var amount = Size.read(arguments),
@@ -811,21 +815,23 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
     },
 
     /**
-     * Scales the rectangle by the specified amount from its center.
+     * Returns a new rectangle scaled by the specified amount from its center.
      *
      * @name Rectangle#scale
      * @function
      * @param {Number} amount
+     * @return {Rectangle} the scaled rectangle
      */
     /**
-     * Scales the rectangle in horizontal direction by the specified `hor`
-     * amount and in vertical direction by the specified `ver` amount from its
-     * center.
+     * Returns a new rectangle scaled in horizontal direction by the specified
+     * `hor` amount and in vertical direction by the specified `ver` amount
+     * from its center.
      *
      * @name Rectangle#scale
      * @function
      * @param {Number} hor
      * @param {Number} ver
+     * @return {Rectangle} the scaled rectangle
      */
     scale: function(hor, ver) {
         return this.expand(this.width * hor - this.width,

From 2e75467fb49218749764f299275c50a3dc75538c Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Tue, 16 Oct 2018 17:47:26 +0200
Subject: [PATCH 004/181] Fix group selected bounds and position color

Group selected color was applied differently to its bounds and position
depending on whether it had children or not when selected color was set.
This resulted in an unpredictable behaviour from a user point of view.
To change that:
- When `item.setSelectedColor()` is called, value is now always stored
in `item._style._values`, independently from the fact that item has
children or not.
- An helper method `compareCanvas()` is added to the test suite to allow
comparing selection rendering of a known working case to a failing one.
Two provided callbacks are executed in a dedicated `<canvas>`/`Project`
context and both results are compared with `resemble.js`.
---
 src/style/Style.js  |  14 ++--
 test/helpers.js     | 159 +++++++++++++++++++++++++++++---------------
 test/tests/Group.js |  22 +++++-
 3 files changed, 137 insertions(+), 58 deletions(-)

diff --git a/src/style/Style.js b/src/style/Style.js
index f8e10280..2e58b283 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -162,13 +162,19 @@ var Style = Base.extend(new function() {
         //   raw value is stored, and conversion only happens in the getter.
         fields[set] = function(value) {
             var owner = this._owner,
-                children = owner && owner._children;
+                children = owner && owner._children,
+                applyToChildren = children && children.length > 0
+                    && !(owner instanceof CompoundPath);
             // Only unify styles on children of Groups, excluding CompoundPaths.
-            if (children && children.length > 0
-                    && !(owner instanceof CompoundPath)) {
+            if (applyToChildren) {
                 for (var i = 0, l = children.length; i < l; i++)
                     children[i]._style[set](value);
-            } else if (key in this._defaults) {
+            }
+            // Always store selectedColor in item _values to make sure that
+            // group selected bounds and position color is coherent whether it
+            // has children or not when the value is set.
+            if ((key === 'selectedColor' || !applyToChildren)
+                    && key in this._defaults) {
                 var old = this._values[key];
                 if (old !== value) {
                     if (isColor) {
diff --git a/test/helpers.js b/test/helpers.js
index 4ccc68ba..4cd62ca5 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -161,6 +161,72 @@ var compareProperties = function(actual, expected, properties, message, options)
     }
 };
 
+/**
+ * Compare 2 image data with resemble.js library.
+ * When comparison fails, expected, actual and compared images are displayed.
+ * @param {ImageData} imageData1 the expected image data
+ * @param {ImageData} imageData2 the actual image data
+ * @param {number} tolerance
+ * @param {string} diffDetail text displayed when comparison fails
+ */
+var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
+    /**
+     * Build an image element from a given image data.
+     * @param {ImageData} imageData
+     * @return {HTMLImageElement}
+     */
+    function image(imageData) {
+        var canvas = CanvasProvider.getCanvas(imageData.width, imageData.height);
+        canvas.getContext('2d').putImageData(imageData, 0, 0);
+        var image = new Image();
+        image.src = canvas.toDataURL();
+        CanvasProvider.release(canvas);
+        return image;
+    }
+
+    tolerance = (tolerance || 1e-4) * 100;
+
+    // Use resemble.js to compare image datas.
+    var id = QUnit.config.current.testId,
+        index = QUnit.config.current.assertions.length + 1,
+        result;
+    if (!resemble._setup) {
+        resemble._setup = true;
+        resemble.outputSettings({
+            errorColor: { red: 255, green: 51, blue: 0 },
+            errorType: 'flat',
+            transparency: 1
+        });
+    }
+    resemble(imageData1)
+    .compareTo(imageData2)
+    .ignoreAntialiasing()
+    // When working with imageData, this call is synchronous:
+    .onComplete(function(data) { result = data; });
+    // Compare with tolerance in percentage...
+    var fixed = tolerance < 1 ? ((1 / tolerance) + '').length - 1 : 0,
+        identical = result ? 100 - result.misMatchPercentage : 0,
+        ok = Math.abs(100 - identical) <= tolerance,
+        text = identical.toFixed(fixed) + '% identical',
+        detail = text;
+    if (!ok && diffDetail) {
+        detail += diffDetail;
+    }
+    QUnit.push(ok, text, (100).toFixed(fixed) + '% identical');
+    if (!ok && result && !isNode) {
+        // Get the right entry for this unit test and assertion, and
+        // replace the results with images
+        var entry = document.getElementById('qunit-test-output-' + id)
+            .querySelector('li:nth-child(' + (index) + ')'),
+            bounds = result.diffBounds;
+        entry.querySelector('.test-expected td').appendChild(image(imageData1));
+        entry.querySelector('.test-actual td').appendChild(image(imageData2));
+        entry.querySelector('.test-diff td').innerHTML = '<pre>' + detail
+            + '</pre><br>'
+            + '<img src="' + result.getImageDataUrl() + '">';
+    }
+};
+
 var comparePixels = function(actual, expected, message, options) {
     function rasterize(item, group, resolution) {
         var raster = null;
@@ -178,11 +244,6 @@ var comparePixels = function(actual, expected, message, options) {
         return raster;
     }
 
-    function getImageTag(raster) {
-        return '<img width="' + raster.width + '" height="' + raster.height
-                + '" src="' + raster.source + '">';
-    }
-
     if (!expected) {
         return QUnit.strictEqual(actual, expected, message, options);
     } else if (!actual) {
@@ -199,8 +260,8 @@ var comparePixels = function(actual, expected, message, options) {
         actualBounds = actual.strokeBounds,
         expecedBounds = expected.strokeBounds,
         bounds = actualBounds.isEmpty()
-                ? expecedBounds
-                : expecedBounds.isEmpty()
+            ? expecedBounds
+            : expecedBounds.isEmpty()
                 ? actualBounds
                 : actualBounds.unite(expecedBounds);
     if (bounds.isEmpty()) {
@@ -220,53 +281,15 @@ var comparePixels = function(actual, expected, message, options) {
         expectedRaster = rasterize(expected, group, resolution);
     if (!actualRaster || !expectedRaster) {
         QUnit.push(false, null, null, 'Unable to compare rasterized items: ' +
-                (!actualRaster ? 'actual' : 'expected') + ' item is null',
-                QUnit.stack(2));
+            (!actualRaster ? 'actual' : 'expected') + ' item is null',
+            QUnit.stack(2));
     } else {
-        // Use resemble.js to compare the two rasterized items.
-        var id = QUnit.config.current.testId,
-            index = QUnit.config.current.assertions.length + 1,
-            result;
-        if (!resemble._setup) {
-            resemble._setup = true;
-            resemble.outputSettings({
-                errorColor: { red: 255, green: 51, blue: 0 },
-                errorType: 'flat',
-                transparency: 1
-            });
-        }
-        resemble(actualRaster.getImageData())
-            .compareTo(expectedRaster.getImageData())
-            .ignoreAntialiasing()
-            // When working with imageData, this call is synchronous:
-            .onComplete(function(data) { result = data; });
-         // Compare with tolerance in percentage...
-        var tolerance = (options.tolerance || 1e-4) * 100,
-            fixed = tolerance < 1 ? ((1 / tolerance) + '').length - 1 : 0,
-            identical = result ? 100 - result.misMatchPercentage : 0,
-            ok = Math.abs(100 - identical) <= tolerance,
-            text = identical.toFixed(fixed) + '% identical',
-            detail = text;
-        if (!ok &&
-                actual instanceof PathItem && expected instanceof PathItem) {
-            detail += '\nExpected:\n' + expected.pathData +
-                    '\nActual:\n' + actual.pathData;
-        }
-        QUnit.push(ok, text, (100).toFixed(fixed) + '% identical', message);
-        if (!ok && result && !isNode) {
-            // Get the right entry for this unit test and assertion, and
-            // replace the results with images
-            var entry = document.getElementById('qunit-test-output-' + id)
-                    .querySelector('li:nth-child(' + (index) + ')'),
-                bounds = result.diffBounds;
-            entry.querySelector('.test-expected td').innerHTML =
-                    getImageTag(expectedRaster);
-            entry.querySelector('.test-actual td').innerHTML =
-                    getImageTag(actualRaster);
-            entry.querySelector('.test-diff td').innerHTML = '<pre>' + detail
-                    + '</pre><br>'
-                    + '<img src="' + result.getImageDataUrl() + '">';
-        }
+        // Compare the two rasterized items.
+        var detail = actual instanceof PathItem && expected instanceof PathItem
+            ? '\nExpected:\n' + expected.pathData + '\nActual:\n' + actual.pathData
+            : '';
+        compareImageData(actualRaster.getImageData(),
+            expectedRaster.getImageData(), options.tolerance, detail);
     }
 };
 
@@ -304,6 +327,36 @@ var compareItem = function(actual, expected, message, options, properties) {
     }
 };
 
+/**
+ * Run each callback in a separated canvas context and compare both outputs.
+ * This can be used to do selection drawing tests as it is not possible with
+ * comparePixels() method which relies on the item.rasterize() method which
+ * ignores selection.
+ * @param width the width of the canvas
+ * @param height the height of the canvas
+ * @param expectedCallback the function producing the expected result
+ * @param actualCallback the function producing the actual result
+ */
+var compareCanvas = function(width, height, expectedCallback, actualCallback) {
+    function getImageData(width, height, callback) {
+        var canvas = CanvasProvider.getCanvas(width, height);
+        var project = new Project(canvas);
+        callback();
+        project.view.update();
+        var imageData = canvas.getContext('2d').getImageData(0, 0, width, height);
+        CanvasProvider.release(canvas);
+        project.remove();
+        return imageData;
+    }
+
+    compareImageData(
+        getImageData(width, height, expectedCallback),
+        getImageData(width, height, actualCallback)
+    );
+
+    currentProject.activate();
+};
+
 // A list of comparator functions, based on `expected` type. See equals() for
 // an explanation of how the type is determined.
 var comparators = {
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 3f542204..cc783d4e 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -134,4 +134,24 @@ test('group.addChildren()', function() {
     group.addChildren(children);
     equals(group.children.length, 2,
             'adding the same item twice should only add it once.');
-})
+});
+
+test('group.setSelectedColor() with selected bound and position', function() {
+    compareCanvas(100, 100,
+        function() {
+            // working: set selected color first then add child
+            var group = new Group();
+            group.bounds.selected = true;
+            group.position.selected = true;
+            group.selectedColor = 'black';
+            group.addChild(new Path.Circle([50, 50], 40));
+        }, function() {
+            // failing: add child first then set selected color
+            var group = new Group();
+            group.bounds.selected = true;
+            group.position.selected = true;
+            group.addChild(new Path.Circle([50, 50], 40));
+            group.selectedColor = 'black';
+        }
+    );
+});

From 337538b21aba1a006fe4ce8dfbb52f4992e58009 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Thu, 18 Oct 2018 09:19:03 +0200
Subject: [PATCH 005/181] Remove reference to CanvasProvider in test methods

---
 test/helpers.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/test/helpers.js b/test/helpers.js
index 4cd62ca5..f18aed3e 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -176,11 +176,13 @@ var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
      * @return {HTMLImageElement}
      */
     function image(imageData) {
-        var canvas = CanvasProvider.getCanvas(imageData.width, imageData.height);
+        var canvas = document.createElement('canvas');
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
         canvas.getContext('2d').putImageData(imageData, 0, 0);
         var image = new Image();
         image.src = canvas.toDataURL();
-        CanvasProvider.release(canvas);
+        canvas.remove();
         return image;
     }
 
@@ -339,12 +341,14 @@ var compareItem = function(actual, expected, message, options, properties) {
  */
 var compareCanvas = function(width, height, expectedCallback, actualCallback) {
     function getImageData(width, height, callback) {
-        var canvas = CanvasProvider.getCanvas(width, height);
+        var canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
         var project = new Project(canvas);
         callback();
         project.view.update();
         var imageData = canvas.getContext('2d').getImageData(0, 0, width, height);
-        CanvasProvider.release(canvas);
+        canvas.remove();
         project.remove();
         return imageData;
     }

From 655a4dabd005f222f57b93904e1199d53db73b2b Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Tue, 6 Nov 2018 12:07:01 +0100
Subject: [PATCH 006/181] Add tolerance parameter to test method
 `compareCanvas()`

---
 test/helpers.js | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/test/helpers.js b/test/helpers.js
index f18aed3e..08e7c4a2 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -334,12 +334,13 @@ var compareItem = function(actual, expected, message, options, properties) {
  * This can be used to do selection drawing tests as it is not possible with
  * comparePixels() method which relies on the item.rasterize() method which
  * ignores selection.
- * @param width the width of the canvas
- * @param height the height of the canvas
- * @param expectedCallback the function producing the expected result
- * @param actualCallback the function producing the actual result
+ * @param {number} width the width of the canvas
+ * @param {number} height the height of the canvas
+ * @param {function} expectedCallback the function producing the expected result
+ * @param {function} actualCallback the function producing the actual result
+ * @param {number} tolerance between 0 and 1
  */
-var compareCanvas = function(width, height, expectedCallback, actualCallback) {
+var compareCanvas = function(width, height, expectedCallback, actualCallback, tolerance) {
     function getImageData(width, height, callback) {
         var canvas = document.createElement('canvas');
         canvas.width = width;
@@ -355,7 +356,8 @@ var compareCanvas = function(width, height, expectedCallback, actualCallback) {
 
     compareImageData(
         getImageData(width, height, expectedCallback),
-        getImageData(width, height, actualCallback)
+        getImageData(width, height, actualCallback),
+        tolerance
     );
 
     currentProject.activate();

From d3f617b98edf723331dc1463b95fb67e827deadf Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 9 Nov 2018 14:24:04 +0100
Subject: [PATCH 007/181] Fix Path#divide() documentation

Divide operation was described as subtract & subtract instead of
subtract & intersect.
---
 src/path/PathItem.Boolean.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index f4f098e4..772d69c6 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -1125,7 +1125,7 @@ PathItem.inject(new function() {
         /**
          * Splits the geometry of this path along the geometry of the specified
          * path returns the result as a new group item. This is equivalent to
-         * calling {@link #subtract(path)} and {@link #subtract(path)} and
+         * calling {@link #subtract(path)} and {@link #intersect(path)} and
          * putting the results into a new group.
          *
          * @option [options.insert=true] {Boolean} whether the resulting item

From df109ab096d6fcb7124cae445ad4fabc578bd570 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:08:04 +0100
Subject: [PATCH 008/181] Fix typo in PathItem documentation

PathItem was misspelled PahtItem, breaking documentation links.
---
 src/path/PathItem.Boolean.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 772d69c6..b9369ed3 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -1156,7 +1156,7 @@ PathItem.inject(new function() {
          * amount of resulting paths allows so, otherwise a new path /
          * compound-path is created, replacing the current one.
          *
-         * @return {PahtItem} the resulting path item
+         * @return {PathItem} the resulting path item
          */
         resolveCrossings: function() {
             var children = this._children,
@@ -1278,7 +1278,7 @@ PathItem.inject(new function() {
          * @param {Boolean} [clockwise] if provided, the orientation of the root
          *     paths will be set to the orientation specified by `clockwise`,
          *     otherwise the orientation of the largest root child is used.
-         * @return {PahtItem} a reference to the item itself, reoriented
+         * @return {PathItem} a reference to the item itself, reoriented
          */
         reorient: function(nonZero, clockwise) {
             var children = this._children;

From bb6331057837d94769c7558e77aadfc088df4777 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:12:01 +0100
Subject: [PATCH 009/181] Fix CurveLocation#index documented type

---
 src/path/CurveLocation.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index cd878d45..64c106af 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -159,7 +159,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
      * it is part of a {@link Path} item.
      *
      * @bean
-     * @type Index
+     * @type Number
      */
     getIndex: function() {
         var curve = this.getCurve();

From 4f545d243bafcc2e93f4c0d92eaf66ffeba1c869 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:18:05 +0100
Subject: [PATCH 010/181] Fix unexisting type `Symbol` in documentation

---
 src/item/SymbolDefinition.js | 4 ++--
 src/item/SymbolItem.js       | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/item/SymbolDefinition.js b/src/item/SymbolDefinition.js
index 9e79b27d..6a6bd434 100644
--- a/src/item/SymbolDefinition.js
+++ b/src/item/SymbolDefinition.js
@@ -140,7 +140,7 @@ var SymbolDefinition = Base.extend(/** @lends SymbolDefinition# */{
     /**
      * Returns a copy of the symbol.
      *
-     * @return {Symbol}
+     * @return {SymbolDefinition}
      */
     clone: function() {
         return new SymbolDefinition(this._item.clone(false));
@@ -149,7 +149,7 @@ var SymbolDefinition = Base.extend(/** @lends SymbolDefinition# */{
     /**
      * Checks whether the symbol's definition is equal to the supplied symbol.
      *
-     * @param {Symbol} symbol
+     * @param {SymbolDefinition} symbol
      * @return {Boolean} {@true if they are equal}
      */
     equals: function(symbol) {
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 3e78646c..e901b4c5 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -31,7 +31,7 @@ var SymbolItem = Item.extend(/** @lends SymbolItem# */{
     /**
      * Creates a new symbol item.
      *
-     * @param {Symbol} definition the symbol definition to place
+     * @param {Item} definition the symbol definition to place
      * @param {Point} [point] the center point of the placed symbol
      *
      * @example {@paperscript split=true height=240}

From 6301aeb82d8ce05513f72f2601993d2227dad3c7 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:20:39 +0100
Subject: [PATCH 011/181] Fix Raster#context documented type

---
 src/item/Raster.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index 1904d8bf..5b3eb88a 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -330,7 +330,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      * The Canvas 2D drawing context of the raster.
      *
      * @bean
-     * @type Context
+     * @type CanvasRenderingContext2D
      */
     getContext: function(modify) {
         if (!this._context)

From 0b52720bdfaa348185c468e19a5f861232b2b943 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:27:23 +0100
Subject: [PATCH 012/181] Fix CompoundPath#lastSegment documentation

---
 src/path/CompoundPath.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path/CompoundPath.js b/src/path/CompoundPath.js
index d1bedfd3..70367261 100644
--- a/src/path/CompoundPath.js
+++ b/src/path/CompoundPath.js
@@ -193,7 +193,7 @@ var CompoundPath = PathItem.extend(/** @lends CompoundPath# */{
 
     /**
      * The last Segment contained within the compound-path, a short-cut to
-     * calling {@link Path#lastChild} on {@link Item#lastChild}.
+     * calling {@link Path#lastSegment} on {@link Item#lastChild}.
      *
      * @bean
      * @type Segment

From 8b33eccd52e6cc5ea46510edd81b5db7bc97b2a2 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:38:34 +0100
Subject: [PATCH 013/181] Fix beans documentation links

Several documentation "see also" links concerning beans were broken
because they were referenced as `ClassName#getProperty()` instead of
`ClassName#property`.
---
 src/basic/Point.js       | 2 +-
 src/path/CompoundPath.js | 2 +-
 src/path/PathItem.js     | 4 ++--
 src/path/Segment.js      | 4 ++--
 src/view/View.js         | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/basic/Point.js b/src/basic/Point.js
index e9b260dd..86af7b9a 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -768,7 +768,7 @@ var Point = Base.extend(/** @lends Point# */{
      *
      * @param {Number} quadrant the quadrant to check against
      * @return {Boolean} {@true if either x or y are not a number}
-     * @see #getQuadrant()
+     * @see #quadrant
      */
     isInQuadrant: function(q) {
         // Map quadrant to x & y coordinate pairs and multiply with coordinates,
diff --git a/src/path/CompoundPath.js b/src/path/CompoundPath.js
index 70367261..5982815b 100644
--- a/src/path/CompoundPath.js
+++ b/src/path/CompoundPath.js
@@ -161,7 +161,7 @@ var CompoundPath = PathItem.extend(/** @lends CompoundPath# */{
      *
      * @bean
      * @type Boolean
-     * @see Path#isClosed()
+     * @see Path#closed
      */
     isClosed: function() {
         var children = this._children;
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index ed9037c1..5f852e0d 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -102,8 +102,8 @@ var PathItem = Item.extend(/** @lends PathItem# */{
      *
      * @bean
      * @type Boolean
-     * @see Path#getArea()
-     * @see CompoundPath#getArea()
+     * @see Path#area
+     * @see CompoundPath#area
      */
     isClockwise: function() {
         return this.getArea() >= 0;
diff --git a/src/path/Segment.js b/src/path/Segment.js
index 298065ec..6c516063 100644
--- a/src/path/Segment.js
+++ b/src/path/Segment.js
@@ -234,8 +234,8 @@ var Segment = Base.extend(/** @lends Segment# */{
      * Checks if the segment has any curve handles set.
      *
      * @return {Boolean} {@true if the segment has handles set}
-     * @see Segment#getHandleIn()
-     * @see Segment#getHandleOut()
+     * @see Segment#handleIn
+     * @see Segment#handleOut
      * @see Curve#hasHandles()
      * @see Path#hasHandles()
      */
diff --git a/src/view/View.js b/src/view/View.js
index 281670f1..6b681e3e 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -522,7 +522,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @bean
      * @type Number
-     * @see #getScaling()
+     * @see #scaling
      */
     getZoom: function() {
         var scaling = this._decompose().scaling;
@@ -559,7 +559,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @bean
      * @type Point
-     * @see #getZoom()
+     * @see #zoom
      */
     getScaling: function() {
         var scaling = this._decompose().scaling;

From 910aecb7e50a85fd7f7c4c7531ba7556e21f48cf Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 12 Nov 2018 16:44:36 +0100
Subject: [PATCH 014/181] Fix CurveLocation#distance documentation

@see tag was pointing to an inherited method which is not compatible
with current jsdoc parser implementation.
Problem is resolved by making reference point to the parent class
owning the method.
---
 src/path/CurveLocation.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 64c106af..bbbfe0b1 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -284,7 +284,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
      * @bean
      * @type Number
      * @see Curve#getNearestLocation(point)
-     * @see Path#getNearestLocation(point)
+     * @see PathItem#getNearestLocation(point)
      */
     getDistance: function() {
         return this._distance;

From 14621787992324fd3d846252bf9d05550e30cc6b Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Tue, 13 Nov 2018 09:52:19 +0100
Subject: [PATCH 015/181] Fix typo in Path(pathData) documentation

Empty parameter was resulting in `Path(pathData)` being documented as
`Path(, pathData)` with an empty first parameter.
---
 src/path/Path.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/path/Path.js b/src/path/Path.js
index 7bda104f..0f747992 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -75,7 +75,6 @@ var Path = PathItem.extend(/** @lends Path# */{
      * Creates a new path item from SVG path-data and places it at the top of
      * the active layer.
      *
-     * @param
      * @name Path#initialize
      * @param {String} pathData the SVG path-data that describes the geometry
      * of this path

From 8202f78453411c54bd197fc3f0dc15f0f897230b Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Tue, 13 Nov 2018 10:12:59 +0100
Subject: [PATCH 016/181] Fix typo in Color#convert documentation

---
 src/style/Color.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/style/Color.js b/src/style/Color.js
index 05f4691f..968d846f 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -729,7 +729,7 @@ var Color = Base.extend(new function() {
         },
 
         /**
-         * Converts the color another type.
+         * Converts the color to another type.
          *
          * @param {String} type the color type to convert to. Possible values:
          * {@values 'rgb', 'gray', 'hsb', 'hsl'}

From 2968faad5198af11286777d25fa8f6fd473a8818 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Wed, 14 Nov 2018 11:21:40 +0100
Subject: [PATCH 017/181] Fix empty image drawing (#1605)

Empty raster (for example coming from path with empty bound
rasterization, ...) drawing threw error.
This change prevent raster drawing in that case.
Closes #1320
---
 CHANGELOG.md       | 8 ++++++++
 src/item/Raster.js | 3 ++-
 test/tests/Item.js | 6 ++++++
 3 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8b5b5ff..9c344537 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Change Log
 
+## Prebuilt version
+
+### Fixed
+
+- Fix empty image drawing (#1320).
+
+### Added
+
 ## `0.11.8`
 
 ### News
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 5b3eb88a..92620eb9 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -753,7 +753,8 @@ var Raster = Item.extend(/** @lends Raster# */{
 
     _draw: function(ctx, param, viewMatrix) {
         var element = this.getElement();
-        if (element) {
+        // Only draw if image is not empty (#1320).
+        if (element && element.width > 0 && element.height > 0) {
             // Handle opacity for Rasters separately from the rest, since
             // Rasters never draw a stroke. See Item#draw().
             ctx.globalAlpha = this._opacity;
diff --git a/test/tests/Item.js b/test/tests/Item.js
index fa226b93..4e7abce9 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -945,3 +945,9 @@ test('Children global matrices are cleared after parent transformation', functio
     group.translate(100, 0);
     equals(item.localToGlobal(item.getPointAt(0)), new Point(100, 100));
 });
+
+test('Item#rasterize() with empty bounds', function() {
+    new Path.Line([0, 0], [100, 0]).rasterize();
+    view.update();
+    expect(0);
+});

From c219bb7345e65a7dba2651c0e61a2abd0f4a0f43 Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Sat, 10 Nov 2018 17:02:46 +0900
Subject: [PATCH 018/181] Replace http to https in comment

---
 src/core/PaperScript.js      | 2 +-
 src/paper.js                 | 2 +-
 src/path/Curve.js            | 4 ++--
 src/path/PathItem.Boolean.js | 2 +-
 src/view/CanvasView.js       | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index 152ded69..aecc290f 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -323,7 +323,7 @@ Base.exports.PaperScript = function() {
 
         // Source-map support:
         // Encodes a Variable Length Quantity as a Base64 string.
-        // See: http://www.html5rocks.com/en/tutorials/developertools/sourcemaps
+        // See: https://www.html5rocks.com/en/tutorials/developertools/sourcemaps/
         function encodeVLQ(value) {
             var res = '',
                 base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
diff --git a/src/paper.js b/src/paper.js
index f2c6d327..f5387440 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -23,7 +23,7 @@
  ***
  *
  * Acorn.js
- * http://marijnhaverbeke.nl/acorn/
+ * https://marijnhaverbeke.nl/acorn/
  *
  * Acorn is a tiny, fast JavaScript parser written in JavaScript,
  * created by Marijn Haverbeke and released under an MIT license.
diff --git a/src/path/Curve.js b/src/path/Curve.js
index 1c5b6714..6ec86979 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -1476,7 +1476,7 @@ new function() { // Scope for methods that require private functions
             // 2: normal, 1st derivative
             // 3: curvature, 1st derivative & 2nd derivative
             // Prevent tangents and normals of length 0:
-            // http://stackoverflow.com/questions/10506868/
+            // https://stackoverflow.com/questions/10506868/
             if (t < tMin) {
                 x = cx;
                 y = cy;
@@ -1698,7 +1698,7 @@ new function() { // Scope for methods that require private functions
          * Peaks are locations sharing some qualities of curvature extrema but
          * are cheaper to compute. They fulfill their purpose here quite well.
          * See:
-         * http://math.stackexchange.com/questions/1954845/bezier-curvature-extrema
+         * https://math.stackexchange.com/questions/1954845/bezier-curvature-extrema
          *
          * @param {Number[]} v the curve values array
          * @return {Number[]} the roots of all found peaks
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index b9369ed3..ba8dc94a 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -25,7 +25,7 @@
  * @author Harikrishnan Gopalakrishnan <hari.exeption@gmail.com>
  * @author Jan Boesenberg <development@iconexperience.com>
  * @author Juerg Lehni <juerg@scratchdisk.com>
- * http://hkrish.com/playground/paperjs/booleanStudy.html
+ * https://hkrish.com/playground/paperjs/booleanStudy.html
  */
 PathItem.inject(new function() {
     var min = Math.min,
diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index 3afdfa68..5bc805e3 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -49,7 +49,7 @@ var CanvasView = View.extend(/** @lends CanvasView# */{
         this._pixelRatio = 1;
         if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
             // Hi-DPI Canvas support based on:
-            // http://www.html5rocks.com/en/tutorials/canvas/hidpi/
+            // https://www.html5rocks.com/en/tutorials/canvas/hidpi/
             var deviceRatio = window.devicePixelRatio || 1,
                 backingStoreRatio = DomElement.getPrefixed(ctx,
                         'backingStorePixelRatio') || 1;

From d8f9eb8890d736a01cb83438ebe4c6a9331751f8 Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Sat, 10 Nov 2018 16:43:09 +0900
Subject: [PATCH 019/181] Replace http to https in comment

http://www.w3.org/TR/SVG/* to https://www.w3.org/TR/SVG/*
---
 src/path/Path.js     |  2 +-
 src/svg/SvgImport.js | 46 ++++++++++++++++++++++----------------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/path/Path.js b/src/path/Path.js
index 0f747992..a1cf5e9f 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2471,7 +2471,7 @@ new function() { // PostScript-style drawing commands
                 if (isZero(radius.width) || isZero(radius.height))
                     return this.lineTo(to);
                 // See for an explanation of the following calculations:
-                // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
+                // https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
                 var rotation = Base.read(arguments),
                     clockwise = !!Base.read(arguments),
                     large = !!Base.read(arguments),
diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 84d3ef0a..7f919ec1 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -196,23 +196,23 @@ new function() {
                     return importNode(child, options, isRoot);
             }
         },
-        // http://www.w3.org/TR/SVG/struct.html#Groups
+        // https://www.w3.org/TR/SVG/struct.html#Groups
         g: importGroup,
-        // http://www.w3.org/TR/SVG/struct.html#NewDocument
+        // https://www.w3.org/TR/SVG/struct.html#NewDocument
         svg: importGroup,
         clippath: importGroup,
-        // http://www.w3.org/TR/SVG/shapes.html#PolygonElement
+        // https://www.w3.org/TR/SVG/shapes.html#PolygonElement
         polygon: importPoly,
-        // http://www.w3.org/TR/SVG/shapes.html#PolylineElement
+        // https://www.w3.org/TR/SVG/shapes.html#PolylineElement
         polyline: importPoly,
-        // http://www.w3.org/TR/SVG/paths.html
+        // https://www.w3.org/TR/SVG/paths.html
         path: importPath,
-        // http://www.w3.org/TR/SVG/pservers.html#LinearGradients
+        // https://www.w3.org/TR/SVG/pservers.html#LinearGradients
         lineargradient: importGradient,
-        // http://www.w3.org/TR/SVG/pservers.html#RadialGradients
+        // https://www.w3.org/TR/SVG/pservers.html#RadialGradients
         radialgradient: importGradient,
 
-        // http://www.w3.org/TR/SVG/struct.html#ImageElement
+        // https://www.w3.org/TR/SVG/struct.html#ImageElement
         image: function (node) {
             var raster = new Raster(getValue(node, 'href', true));
             raster.on('load', function() {
@@ -228,17 +228,17 @@ new function() {
             return raster;
         },
 
-        // http://www.w3.org/TR/SVG/struct.html#SymbolElement
+        // https://www.w3.org/TR/SVG/struct.html#SymbolElement
         symbol: function(node, type, options, isRoot) {
             return new SymbolDefinition(
                     // Pass true for dontCenter:
                     importGroup(node, type, options, isRoot), true);
         },
 
-        // http://www.w3.org/TR/SVG/struct.html#DefsElement
+        // https://www.w3.org/TR/SVG/struct.html#DefsElement
         defs: importGroup,
 
-        // http://www.w3.org/TR/SVG/struct.html#UseElement
+        // https://www.w3.org/TR/SVG/struct.html#UseElement
         use: function(node) {
             // Note the namespaced xlink:href attribute is just called href
             // as a property on node.
@@ -258,14 +258,14 @@ new function() {
                     : null;
         },
 
-        // http://www.w3.org/TR/SVG/shapes.html#InterfaceSVGCircleElement
+        // https://www.w3.org/TR/SVG/shapes.html#InterfaceSVGCircleElement
         circle: function(node) {
             return new Shape.Circle(
                     getPoint(node, 'cx', 'cy'),
                     getValue(node, 'r'));
         },
 
-        // http://www.w3.org/TR/SVG/shapes.html#InterfaceSVGEllipseElement
+        // https://www.w3.org/TR/SVG/shapes.html#InterfaceSVGEllipseElement
         ellipse: function(node) {
             // We only use object literal notation where the default one is not
             // supported (e.g. center / radius fo Shape.Ellipse).
@@ -275,7 +275,7 @@ new function() {
             });
         },
 
-        // http://www.w3.org/TR/SVG/shapes.html#RectElement
+        // https://www.w3.org/TR/SVG/shapes.html#RectElement
         rect: function(node) {
             return new Shape.Rectangle(new Rectangle(
                         getPoint(node),
@@ -283,7 +283,7 @@ new function() {
                     ), getSize(node, 'rx', 'ry'));
             },
 
-        // http://www.w3.org/TR/SVG/shapes.html#LineElement
+        // https://www.w3.org/TR/SVG/shapes.html#LineElement
         line: function(node) {
             return new Path.Line(
                     getPoint(node, 'x1', 'y1'),
@@ -314,7 +314,7 @@ new function() {
 
     function applyTransform(item, value, name, node) {
         if (item.transform) {
-            // http://www.w3.org/TR/SVG/types.html#DataTypeTransformList
+            // https://www.w3.org/TR/SVG/types.html#DataTypeTransformList
             // Parse SVG transform string. First we split at /)\s*/, to separate
             // commands
             var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
@@ -357,8 +357,8 @@ new function() {
     }
 
     function applyOpacity(item, value, name) {
-        // http://www.w3.org/TR/SVG/painting.html#FillOpacityProperty
-        // http://www.w3.org/TR/SVG/painting.html#StrokeOpacityProperty
+        // https://www.w3.org/TR/SVG/painting.html#FillOpacityProperty
+        // https://www.w3.org/TR/SVG/painting.html#StrokeOpacityProperty
         var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
             color = item[key] && item[key]();
         if (color)
@@ -400,7 +400,7 @@ new function() {
         },
 
         'clip-path': function(item, value) {
-            // http://www.w3.org/TR/SVG/masking.html#ClipPathProperty
+            // https://www.w3.org/TR/SVG/masking.html#ClipPathProperty
             var clip = getDefinition(value);
             if (clip) {
                 clip = clip.clone();
@@ -432,20 +432,20 @@ new function() {
         },
 
         'stop-color': function(item, value) {
-            // http://www.w3.org/TR/SVG/pservers.html#StopColorProperty
+            // https://www.w3.org/TR/SVG/pservers.html#StopColorProperty
             if (item.setColor)
                 item.setColor(value);
         },
 
         'stop-opacity': function(item, value) {
-            // http://www.w3.org/TR/SVG/pservers.html#StopOpacityProperty
+            // https://www.w3.org/TR/SVG/pservers.html#StopOpacityProperty
             // NOTE: It is important that this is applied after stop-color!
             if (item._color)
                 item._color.setAlpha(parseFloat(value));
         },
 
         offset: function(item, value) {
-            // http://www.w3.org/TR/SVG/pservers.html#StopElementOffsetAttribute
+            // https://www.w3.org/TR/SVG/pservers.html#StopElementOffsetAttribute
             if (item.setOffset) {
                 var percent = value.match(/(.*)%$/);
                 item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
@@ -453,7 +453,7 @@ new function() {
         },
 
         viewBox: function(item, value, name, node, styles) {
-            // http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute
+            // https://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute
             // TODO: implement preserveAspectRatio attribute
             // viewBox will be applied both to the group that's created for the
             // content in SymbolDefinition#item, and the SymbolItem itself.

From cfc5a912da653a4b908b95e4318a7f613112b4e1 Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Sat, 10 Nov 2018 16:19:34 +0900
Subject: [PATCH 020/181] Replace url to avoid redirection

Replace http://jonathanpuckey.com to https://puckey.studio
---
 LICENSE.txt                      | 2 +-
 gulp/tasks/build.js              | 2 +-
 gulp/tasks/dist.js               | 2 +-
 gulp/tasks/docs.js               | 2 +-
 gulp/tasks/jshint.js             | 2 +-
 gulp/tasks/load.js               | 2 +-
 gulp/tasks/minify.js             | 2 +-
 gulp/tasks/publish.js            | 2 +-
 gulp/tasks/test.js               | 2 +-
 gulp/tasks/watch.js              | 2 +-
 gulp/utils/error.js              | 2 +-
 gulp/utils/options.js            | 2 +-
 gulpfile.js                      | 2 +-
 src/basic/Line.js                | 2 +-
 src/basic/Matrix.js              | 2 +-
 src/basic/Point.js               | 2 +-
 src/basic/Rectangle.js           | 2 +-
 src/basic/Size.js                | 2 +-
 src/canvas/BlendMode.js          | 2 +-
 src/canvas/CanvasProvider.js     | 2 +-
 src/canvas/ProxyContext.js       | 2 +-
 src/constants.js                 | 2 +-
 src/core/Base.js                 | 2 +-
 src/core/Emitter.js              | 2 +-
 src/core/PaperScope.js           | 2 +-
 src/core/PaperScopeItem.js       | 2 +-
 src/core/PaperScript.js          | 2 +-
 src/docs/global.js               | 2 +-
 src/dom/DomElement.js            | 2 +-
 src/dom/DomEvent.js              | 2 +-
 src/event/Event.js               | 2 +-
 src/event/Key.js                 | 2 +-
 src/event/KeyEvent.js            | 2 +-
 src/event/MouseEvent.js          | 2 +-
 src/export.js                    | 2 +-
 src/init.js                      | 2 +-
 src/item/ChangeFlag.js           | 2 +-
 src/item/Group.js                | 2 +-
 src/item/HitResult.js            | 2 +-
 src/item/Item.js                 | 2 +-
 src/item/ItemSelection.js        | 2 +-
 src/item/Layer.js                | 2 +-
 src/item/Project.js              | 2 +-
 src/item/Raster.js               | 2 +-
 src/item/Shape.js                | 2 +-
 src/item/SymbolDefinition.js     | 2 +-
 src/item/SymbolItem.js           | 2 +-
 src/load.js                      | 2 +-
 src/net/Http.js                  | 2 +-
 src/node/canvas.js               | 2 +-
 src/node/extend.js               | 2 +-
 src/node/self.js                 | 2 +-
 src/node/xml.js                  | 2 +-
 src/options.js                   | 2 +-
 src/paper.js                     | 2 +-
 src/path/CompoundPath.js         | 2 +-
 src/path/Curve.js                | 2 +-
 src/path/CurveLocation.js        | 2 +-
 src/path/Path.Constructors.js    | 2 +-
 src/path/Path.js                 | 2 +-
 src/path/PathFitter.js           | 2 +-
 src/path/PathFlattener.js        | 2 +-
 src/path/PathItem.Boolean.js     | 2 +-
 src/path/PathItem.js             | 2 +-
 src/path/Segment.js              | 2 +-
 src/path/SegmentPoint.js         | 2 +-
 src/path/SegmentSelection.js     | 2 +-
 src/style/Color.js               | 2 +-
 src/style/Gradient.js            | 2 +-
 src/style/GradientStop.js        | 2 +-
 src/style/Style.js               | 2 +-
 src/svg/SvgElement.js            | 2 +-
 src/svg/SvgExport.js             | 2 +-
 src/svg/SvgImport.js             | 2 +-
 src/svg/SvgStyles.js             | 2 +-
 src/text/PointText.js            | 2 +-
 src/text/TextItem.js             | 2 +-
 src/tool/Tool.js                 | 2 +-
 src/tool/ToolEvent.js            | 2 +-
 src/util/Formatter.js            | 2 +-
 src/util/Numerical.js            | 2 +-
 src/util/UID.js                  | 2 +-
 src/view/CanvasView.js           | 2 +-
 src/view/View.js                 | 2 +-
 test/helpers.js                  | 2 +-
 test/load.js                     | 2 +-
 test/tests/Color.js              | 2 +-
 test/tests/CompoundPath.js       | 2 +-
 test/tests/Curve.js              | 2 +-
 test/tests/CurveLocation.js      | 2 +-
 test/tests/Emitter.js            | 2 +-
 test/tests/Group.js              | 2 +-
 test/tests/HitResult.js          | 2 +-
 test/tests/Interactions.js       | 2 +-
 test/tests/Item.js               | 2 +-
 test/tests/Item_Bounds.js        | 2 +-
 test/tests/Item_Cloning.js       | 2 +-
 test/tests/Item_Getting.js       | 2 +-
 test/tests/Item_Order.js         | 2 +-
 test/tests/JSON.js               | 2 +-
 test/tests/Layer.js              | 2 +-
 test/tests/Matrix.js             | 2 +-
 test/tests/Numerical.js          | 2 +-
 test/tests/Path.js               | 2 +-
 test/tests/PathItem.js           | 2 +-
 test/tests/PathItem_Contains.js  | 2 +-
 test/tests/Path_Boolean.js       | 2 +-
 test/tests/Path_Constructors.js  | 2 +-
 test/tests/Path_Intersections.js | 2 +-
 test/tests/Point.js              | 2 +-
 test/tests/Project.js            | 2 +-
 test/tests/Raster.js             | 2 +-
 test/tests/Rectangle.js          | 2 +-
 test/tests/Segment.js            | 2 +-
 test/tests/Shape.js              | 2 +-
 test/tests/Size.js               | 2 +-
 test/tests/Style.js              | 2 +-
 test/tests/SvgExport.js          | 2 +-
 test/tests/SvgImport.js          | 2 +-
 test/tests/SymbolItem.js         | 2 +-
 test/tests/TextItem.js           | 2 +-
 test/tests/load.js               | 2 +-
 travis/deploy-prebuilt.sh        | 2 +-
 travis/install-assets.sh         | 2 +-
 travis/setup-git.sh              | 2 +-
 125 files changed, 125 insertions(+), 125 deletions(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index 28c2e83f..2a3d5bee 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,5 +1,5 @@
 Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
-http://scratchdisk.com/ & http://jonathanpuckey.com/
+http://scratchdisk.com/ & https://puckey.studio/
 All rights reserved.
 
 The MIT License (MIT)
diff --git a/gulp/tasks/build.js b/gulp/tasks/build.js
index ba2397e7..ca69f4bf 100644
--- a/gulp/tasks/build.js
+++ b/gulp/tasks/build.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index 17ba87bd..f80d2367 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index 01953df9..96728ea4 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/jshint.js b/gulp/tasks/jshint.js
index 382f9154..fa8e5481 100644
--- a/gulp/tasks/jshint.js
+++ b/gulp/tasks/jshint.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/load.js b/gulp/tasks/load.js
index 1d301aab..02740345 100644
--- a/gulp/tasks/load.js
+++ b/gulp/tasks/load.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/minify.js b/gulp/tasks/minify.js
index b55318bc..1ce1f790 100644
--- a/gulp/tasks/minify.js
+++ b/gulp/tasks/minify.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index d1b07c37..f5ea1f92 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/test.js b/gulp/tasks/test.js
index 49595ac3..0e42b641 100644
--- a/gulp/tasks/test.js
+++ b/gulp/tasks/test.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/watch.js b/gulp/tasks/watch.js
index 5864e895..441265af 100644
--- a/gulp/tasks/watch.js
+++ b/gulp/tasks/watch.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/utils/error.js b/gulp/utils/error.js
index cfd92c58..3ce10e2d 100644
--- a/gulp/utils/error.js
+++ b/gulp/utils/error.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/utils/options.js b/gulp/utils/options.js
index 013efde9..654978f7 100644
--- a/gulp/utils/options.js
+++ b/gulp/utils/options.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulpfile.js b/gulpfile.js
index 0e6e6fc3..bbde60cf 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Line.js b/src/basic/Line.js
index fc08eb71..74f7ae9f 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index 32d4d75c..f334104a 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 86af7b9a..6bea5a7c 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index b3478df3..cf7a804c 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Size.js b/src/basic/Size.js
index af10e6b5..b57ec6a2 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/BlendMode.js b/src/canvas/BlendMode.js
index d3342bd8..a147bc2b 100644
--- a/src/canvas/BlendMode.js
+++ b/src/canvas/BlendMode.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/CanvasProvider.js b/src/canvas/CanvasProvider.js
index dd9ced59..40460759 100644
--- a/src/canvas/CanvasProvider.js
+++ b/src/canvas/CanvasProvider.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/ProxyContext.js b/src/canvas/ProxyContext.js
index b709bbde..1d3b540f 100644
--- a/src/canvas/ProxyContext.js
+++ b/src/canvas/ProxyContext.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/constants.js b/src/constants.js
index b360edf0..7c54cdee 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/Base.js b/src/core/Base.js
index 834c940f..2d2a4a13 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/Emitter.js b/src/core/Emitter.js
index 0ad43233..44e5e81c 100644
--- a/src/core/Emitter.js
+++ b/src/core/Emitter.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index e60b834b..4bb5c42f 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScopeItem.js b/src/core/PaperScopeItem.js
index f03b8904..f0381ba8 100644
--- a/src/core/PaperScopeItem.js
+++ b/src/core/PaperScopeItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index aecc290f..6d7d79b5 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/docs/global.js b/src/docs/global.js
index 4d8c8a82..eda33ba7 100644
--- a/src/docs/global.js
+++ b/src/docs/global.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/dom/DomElement.js b/src/dom/DomElement.js
index 035f6cab..72e047f0 100644
--- a/src/dom/DomElement.js
+++ b/src/dom/DomElement.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/dom/DomEvent.js b/src/dom/DomEvent.js
index c6786006..ca1e6cad 100644
--- a/src/dom/DomEvent.js
+++ b/src/dom/DomEvent.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/Event.js b/src/event/Event.js
index 5beca73c..94e9515f 100644
--- a/src/event/Event.js
+++ b/src/event/Event.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/Key.js b/src/event/Key.js
index c8746429..36590d0b 100644
--- a/src/event/Key.js
+++ b/src/event/Key.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/KeyEvent.js b/src/event/KeyEvent.js
index c20af658..8c7e0f70 100644
--- a/src/event/KeyEvent.js
+++ b/src/event/KeyEvent.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/MouseEvent.js b/src/event/MouseEvent.js
index 93859adb..485693d6 100644
--- a/src/event/MouseEvent.js
+++ b/src/event/MouseEvent.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/export.js b/src/export.js
index 0ac7f578..8bdef8d8 100644
--- a/src/export.js
+++ b/src/export.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/init.js b/src/init.js
index 7083208b..d0e399d7 100644
--- a/src/init.js
+++ b/src/init.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/ChangeFlag.js b/src/item/ChangeFlag.js
index fd1aaede..778bbfa4 100644
--- a/src/item/ChangeFlag.js
+++ b/src/item/ChangeFlag.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Group.js b/src/item/Group.js
index f9e36070..ea3787de 100644
--- a/src/item/Group.js
+++ b/src/item/Group.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/HitResult.js b/src/item/HitResult.js
index 460ee4b0..cc644373 100644
--- a/src/item/HitResult.js
+++ b/src/item/HitResult.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Item.js b/src/item/Item.js
index 78ef2756..fa80bc29 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/ItemSelection.js b/src/item/ItemSelection.js
index 94d75180..98acfd73 100644
--- a/src/item/ItemSelection.js
+++ b/src/item/ItemSelection.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Layer.js b/src/item/Layer.js
index 5650f505..5f3bf5ec 100644
--- a/src/item/Layer.js
+++ b/src/item/Layer.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Project.js b/src/item/Project.js
index 8a7ad5c4..8dbeef20 100644
--- a/src/item/Project.js
+++ b/src/item/Project.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 92620eb9..c839ae80 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Shape.js b/src/item/Shape.js
index 184362a9..6a00ffa7 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/SymbolDefinition.js b/src/item/SymbolDefinition.js
index 6a6bd434..2cd43f34 100644
--- a/src/item/SymbolDefinition.js
+++ b/src/item/SymbolDefinition.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index e901b4c5..0f84beb3 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/load.js b/src/load.js
index 59e08c7c..ff92efff 100644
--- a/src/load.js
+++ b/src/load.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/net/Http.js b/src/net/Http.js
index 012f6b92..a7b138e3 100644
--- a/src/net/Http.js
+++ b/src/net/Http.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/canvas.js b/src/node/canvas.js
index fcb96540..3f122a4b 100644
--- a/src/node/canvas.js
+++ b/src/node/canvas.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/extend.js b/src/node/extend.js
index d2e1ef66..e994d7b4 100644
--- a/src/node/extend.js
+++ b/src/node/extend.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/self.js b/src/node/self.js
index b6e47d8f..9232b5d5 100644
--- a/src/node/self.js
+++ b/src/node/self.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/xml.js b/src/node/xml.js
index 2a02ae7e..04eaa168 100644
--- a/src/node/xml.js
+++ b/src/node/xml.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/options.js b/src/options.js
index 5ec47207..373d78eb 100644
--- a/src/options.js
+++ b/src/options.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/paper.js b/src/paper.js
index f5387440..0fcf9ff1 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/CompoundPath.js b/src/path/CompoundPath.js
index 5982815b..5f6d0281 100644
--- a/src/path/CompoundPath.js
+++ b/src/path/CompoundPath.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Curve.js b/src/path/Curve.js
index 6ec86979..7587037e 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index bbbfe0b1..309c5d99 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Path.Constructors.js b/src/path/Path.Constructors.js
index 3cc23b9d..0664263e 100644
--- a/src/path/Path.Constructors.js
+++ b/src/path/Path.Constructors.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Path.js b/src/path/Path.js
index a1cf5e9f..311ffc1e 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathFitter.js b/src/path/PathFitter.js
index b9d10300..86c97dbd 100644
--- a/src/path/PathFitter.js
+++ b/src/path/PathFitter.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathFlattener.js b/src/path/PathFlattener.js
index 1df208a4..10bf4605 100644
--- a/src/path/PathFlattener.js
+++ b/src/path/PathFlattener.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index ba8dc94a..90f19bf5 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index 5f852e0d..d0e9a51d 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Segment.js b/src/path/Segment.js
index 6c516063..5a732f3a 100644
--- a/src/path/Segment.js
+++ b/src/path/Segment.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/SegmentPoint.js b/src/path/SegmentPoint.js
index 2289bda0..4e2d22b5 100644
--- a/src/path/SegmentPoint.js
+++ b/src/path/SegmentPoint.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/SegmentSelection.js b/src/path/SegmentSelection.js
index 559ef294..429545cb 100644
--- a/src/path/SegmentSelection.js
+++ b/src/path/SegmentSelection.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Color.js b/src/style/Color.js
index 968d846f..e219c6e3 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Gradient.js b/src/style/Gradient.js
index 4fd6b6ea..10f7a93b 100644
--- a/src/style/Gradient.js
+++ b/src/style/Gradient.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/GradientStop.js b/src/style/GradientStop.js
index 96e78464..f3ef46ef 100644
--- a/src/style/GradientStop.js
+++ b/src/style/GradientStop.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Style.js b/src/style/Style.js
index 2e58b283..6b90885a 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgElement.js b/src/svg/SvgElement.js
index df34143c..4dfa9d48 100644
--- a/src/svg/SvgElement.js
+++ b/src/svg/SvgElement.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index 382a49e5..8daf6bb6 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 7f919ec1..76053626 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgStyles.js b/src/svg/SvgStyles.js
index af1827e2..da1c54f0 100644
--- a/src/svg/SvgStyles.js
+++ b/src/svg/SvgStyles.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/text/PointText.js b/src/text/PointText.js
index 0886862e..3740da57 100644
--- a/src/text/PointText.js
+++ b/src/text/PointText.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/text/TextItem.js b/src/text/TextItem.js
index b6d56bfe..d35d59c6 100644
--- a/src/text/TextItem.js
+++ b/src/text/TextItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/tool/Tool.js b/src/tool/Tool.js
index e3c409e1..22f96800 100644
--- a/src/tool/Tool.js
+++ b/src/tool/Tool.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/tool/ToolEvent.js b/src/tool/ToolEvent.js
index 128de506..136d0278 100644
--- a/src/tool/ToolEvent.js
+++ b/src/tool/ToolEvent.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/Formatter.js b/src/util/Formatter.js
index 2b73c5ba..03c6dafd 100644
--- a/src/util/Formatter.js
+++ b/src/util/Formatter.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/Numerical.js b/src/util/Numerical.js
index b2b3adfd..796dbf4e 100644
--- a/src/util/Numerical.js
+++ b/src/util/Numerical.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/UID.js b/src/util/UID.js
index 9aac04c0..11f8e2d0 100644
--- a/src/util/UID.js
+++ b/src/util/UID.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index 5bc805e3..efc120bb 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/view/View.js b/src/view/View.js
index 6b681e3e..6172eb5e 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/helpers.js b/test/helpers.js
index 08e7c4a2..98f402cc 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/load.js b/test/load.js
index ed1cf72e..2b2796c4 100644
--- a/test/load.js
+++ b/test/load.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Color.js b/test/tests/Color.js
index 32f0cf9d..e1bacfd8 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/CompoundPath.js b/test/tests/CompoundPath.js
index adc0224d..9c807012 100644
--- a/test/tests/CompoundPath.js
+++ b/test/tests/CompoundPath.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Curve.js b/test/tests/Curve.js
index 6a4b6c4a..95dd948e 100644
--- a/test/tests/Curve.js
+++ b/test/tests/Curve.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/CurveLocation.js b/test/tests/CurveLocation.js
index fa3b06c2..e2687a08 100644
--- a/test/tests/CurveLocation.js
+++ b/test/tests/CurveLocation.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Emitter.js b/test/tests/Emitter.js
index 9e55136b..b3207da6 100644
--- a/test/tests/Emitter.js
+++ b/test/tests/Emitter.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Group.js b/test/tests/Group.js
index cc783d4e..98c672ce 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/HitResult.js b/test/tests/HitResult.js
index 5ca489f7..d7f913d5 100644
--- a/test/tests/HitResult.js
+++ b/test/tests/HitResult.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Interactions.js b/test/tests/Interactions.js
index f606fb78..7266f5c6 100644
--- a/test/tests/Interactions.js
+++ b/test/tests/Interactions.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 4e7abce9..79f6a396 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Bounds.js b/test/tests/Item_Bounds.js
index f0b8ae03..0796331e 100644
--- a/test/tests/Item_Bounds.js
+++ b/test/tests/Item_Bounds.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Cloning.js b/test/tests/Item_Cloning.js
index 762701d0..1ff197f8 100644
--- a/test/tests/Item_Cloning.js
+++ b/test/tests/Item_Cloning.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Getting.js b/test/tests/Item_Getting.js
index 120d0500..3dc248f4 100644
--- a/test/tests/Item_Getting.js
+++ b/test/tests/Item_Getting.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Order.js b/test/tests/Item_Order.js
index b99814ef..02d4e60b 100644
--- a/test/tests/Item_Order.js
+++ b/test/tests/Item_Order.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/JSON.js b/test/tests/JSON.js
index 1c2fe5af..2bb5fe8a 100644
--- a/test/tests/JSON.js
+++ b/test/tests/JSON.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Layer.js b/test/tests/Layer.js
index c4d2a188..f13bd5de 100644
--- a/test/tests/Layer.js
+++ b/test/tests/Layer.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Matrix.js b/test/tests/Matrix.js
index 6046eaf8..5d3d48c2 100644
--- a/test/tests/Matrix.js
+++ b/test/tests/Matrix.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Numerical.js b/test/tests/Numerical.js
index 01a5cb08..c6cb4843 100644
--- a/test/tests/Numerical.js
+++ b/test/tests/Numerical.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path.js b/test/tests/Path.js
index d985fe7b..ad2c6135 100644
--- a/test/tests/Path.js
+++ b/test/tests/Path.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/PathItem.js b/test/tests/PathItem.js
index 2ac17864..ac969c4d 100644
--- a/test/tests/PathItem.js
+++ b/test/tests/PathItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/PathItem_Contains.js b/test/tests/PathItem_Contains.js
index 30367955..f9ed0b1f 100644
--- a/test/tests/PathItem_Contains.js
+++ b/test/tests/PathItem_Contains.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index ed9061f8..64e00854 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path_Constructors.js b/test/tests/Path_Constructors.js
index 220f0ca4..e5299b69 100644
--- a/test/tests/Path_Constructors.js
+++ b/test/tests/Path_Constructors.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 3d079706..d30a13c7 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Point.js b/test/tests/Point.js
index 41a5d1e6..ddade38b 100644
--- a/test/tests/Point.js
+++ b/test/tests/Point.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Project.js b/test/tests/Project.js
index ca970d01..9fd536f6 100644
--- a/test/tests/Project.js
+++ b/test/tests/Project.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Raster.js b/test/tests/Raster.js
index 883dff1a..b67b90e9 100644
--- a/test/tests/Raster.js
+++ b/test/tests/Raster.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Rectangle.js b/test/tests/Rectangle.js
index af17a14d..0f658a68 100644
--- a/test/tests/Rectangle.js
+++ b/test/tests/Rectangle.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Segment.js b/test/tests/Segment.js
index 3a2107af..ca225bf3 100644
--- a/test/tests/Segment.js
+++ b/test/tests/Segment.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Shape.js b/test/tests/Shape.js
index cc5b59fd..480bf143 100644
--- a/test/tests/Shape.js
+++ b/test/tests/Shape.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Size.js b/test/tests/Size.js
index df21a771..33c1194b 100644
--- a/test/tests/Size.js
+++ b/test/tests/Size.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Style.js b/test/tests/Style.js
index b0d84183..25a12e0c 100644
--- a/test/tests/Style.js
+++ b/test/tests/Style.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index a68f6cd3..feb389aa 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index a7e256bf..2ac5c7b2 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SymbolItem.js b/test/tests/SymbolItem.js
index 23957210..00ea5ec3 100644
--- a/test/tests/SymbolItem.js
+++ b/test/tests/SymbolItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/TextItem.js b/test/tests/TextItem.js
index 4223f249..5e76116c 100644
--- a/test/tests/TextItem.js
+++ b/test/tests/TextItem.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/load.js b/test/tests/load.js
index 17e34a9a..97becd50 100644
--- a/test/tests/load.js
+++ b/test/tests/load.js
@@ -3,7 +3,7 @@
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & http://jonathanpuckey.com/
+ * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/travis/deploy-prebuilt.sh b/travis/deploy-prebuilt.sh
index 491eabc8..3a139901 100755
--- a/travis/deploy-prebuilt.sh
+++ b/travis/deploy-prebuilt.sh
@@ -4,7 +4,7 @@
 # http://paperjs.org/
 #
 # Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & http://jonathanpuckey.com/
+# http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #
diff --git a/travis/install-assets.sh b/travis/install-assets.sh
index 9ca3d767..3286c638 100755
--- a/travis/install-assets.sh
+++ b/travis/install-assets.sh
@@ -4,7 +4,7 @@
 # http://paperjs.org/
 #
 # Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & http://jonathanpuckey.com/
+# http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #
diff --git a/travis/setup-git.sh b/travis/setup-git.sh
index fbc225bf..77339166 100755
--- a/travis/setup-git.sh
+++ b/travis/setup-git.sh
@@ -4,7 +4,7 @@
 # http://paperjs.org/
 #
 # Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & http://jonathanpuckey.com/
+# http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #

From 12731f2fd1989f5a4dd10759b47b4702d914127e Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 16 Nov 2018 18:58:18 +0100
Subject: [PATCH 021/181] Fix typo in Raster#getCanvas documentation

---
 src/item/Raster.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index c839ae80..fb6dc994 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -305,7 +305,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      * case `null` is returned instead.
      *
      * @bean
-     * @type HTMLCanvasELement
+     * @type HTMLCanvasElement
      */
     getCanvas: function() {
         if (!this._canvas) {

From ef7beacd8b0ce5a9b872d16b1a08e8c381172064 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Sat, 17 Nov 2018 09:37:06 +0100
Subject: [PATCH 022/181] Fix several return values documentation

---
 src/core/PaperScript.js | 2 +-
 src/item/Item.js        | 2 +-
 src/item/Project.js     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index 6d7d79b5..f42b76ff 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -442,7 +442,7 @@ Base.exports.PaperScript = function() {
      * @param {String} code the PaperScript code
      * @param {PaperScope} scope the scope for which the code is executed
      * @param {Object} [option] the compilation options
-     * @return the exports defined in the executed code
+     * @return {Object} the exports defined in the executed code
      */
     function execute(code, scope, options) {
         // Set currently active scope.
diff --git a/src/item/Item.js b/src/item/Item.js
index fa80bc29..dda67647 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2832,7 +2832,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * no children, a {@link TextItem} with no text content and a {@link Path}
      * with no segments all are considered empty.
      *
-     * @return Boolean
+     * @return {Boolean}
      */
     isEmpty: function() {
         var children = this._children;
diff --git a/src/item/Project.js b/src/item/Project.js
index 8dbeef20..8f16e7b9 100644
--- a/src/item/Project.js
+++ b/src/item/Project.js
@@ -133,7 +133,7 @@ var Project = PaperScopeItem.extend(/** @lends Project# */{
     /**
      * Checks whether the project has any content or not.
      *
-     * @return Boolean
+     * @return {Boolean}
      */
     isEmpty: function() {
         return !this._children.length;

From 531479c0a0cab795ad609b54a12b5e63b261ec4d Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Tue, 20 Nov 2018 08:44:38 +0900
Subject: [PATCH 023/181] Add param type in raster method

Add param type in Raster#getPixel and Raster#setPixel
---
 src/item/Raster.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index fb6dc994..26256a07 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -606,8 +606,8 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#getPixel
      * @function
-     * @param x the x offset of the pixel in pixel coordinates
-     * @param y the y offset of the pixel in pixel coordinates
+     * @param {Number} x the x offset of the pixel in pixel coordinates
+     * @param {Number} y the y offset of the pixel in pixel coordinates
      * @return {Color} the color of the pixel
      */
     /**
@@ -615,7 +615,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#getPixel
      * @function
-     * @param point the offset of the pixel as a point in pixel coordinates
+     * @param {Point} point the offset of the pixel as a point in pixel coordinates
      * @return {Color} the color of the pixel
      */
     getPixel: function(/* point */) {
@@ -631,17 +631,17 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#setPixel
      * @function
-     * @param x the x offset of the pixel in pixel coordinates
-     * @param y the y offset of the pixel in pixel coordinates
-     * @param color the color that the pixel will be set to
+     * @param {Number} x the x offset of the pixel in pixel coordinates
+     * @param {Number} y the y offset of the pixel in pixel coordinates
+     * @param {Color} color the color that the pixel will be set to
      */
     /**
      * Sets the color of the specified pixel to the specified color.
      *
      * @name Raster#setPixel
      * @function
-     * @param point the offset of the pixel as a point in pixel coordinates
-     * @param color the color that the pixel will be set to
+     * @param {Point} point the offset of the pixel as a point in pixel coordinates
+     * @param {Color} color the color that the pixel will be set to
      */
     setPixel: function(/* point, color */) {
         var point = Point.read(arguments),

From dd2c15ac83f779203e2612500a1d4b4d27622869 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 21 Nov 2018 11:18:02 +0100
Subject: [PATCH 024/181] Add documentation for Color.random()

---
 src/style/Color.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/style/Color.js b/src/style/Color.js
index e219c6e3..dcfb079e 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -1183,6 +1183,17 @@ var Color = Base.extend(new function() {
             // Export for backward compatibility code below.
             _types: types,
 
+            /**
+             * Creates a random color.
+             *
+             * @return {Color} the randomly created color
+             * @static
+             *
+             * @example {@paperscript}
+             * var circle = new Path.Circle(view.center, 50);
+             * // Set a random color as circle fill color.
+             * circle.fillColor = Color.random();
+             */
             random: function() {
                 var random = Math.random;
                 return new Color(random(), random(), random());

From b363a5cc953a335252d561c425eeebf4cda75833 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 21 Nov 2018 11:21:51 +0100
Subject: [PATCH 025/181] Remove Line from documentation

Line class was not displayed in online documentation but it was parsed
and a file was created for it because it lacked a @private JSDoc tag.
---
 src/basic/Line.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/basic/Line.js b/src/basic/Line.js
index 74f7ae9f..4b88fd96 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -12,8 +12,8 @@
 
 /**
  * @name Line
- *
  * @class The Line object represents..
+ * @private
  */
 var Line = Base.extend(/** @lends Line# */{
     _class: 'Line',

From a4a2fb7eefbfebcec0215b3bfb0fc2d2345f9817 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 21 Nov 2018 11:27:51 +0100
Subject: [PATCH 026/181] Fix various documentation problems

- typos in comments
- wrong or missing types
- missing default values
---
 src/basic/Matrix.js       | 12 +++++++-----
 src/basic/Point.js        |  1 +
 src/basic/Rectangle.js    |  4 +++-
 src/basic/Size.js         |  4 +++-
 src/item/Item.js          |  8 ++++++--
 src/item/Project.js       |  6 ++++--
 src/item/Raster.js        |  4 ++--
 src/item/SymbolItem.js    |  4 +++-
 src/path/CurveLocation.js |  2 +-
 src/path/Path.js          |  2 ++
 src/path/PathItem.js      |  2 ++
 src/path/Segment.js       |  3 +++
 src/style/Color.js        |  1 +
 src/style/Style.js        |  2 +-
 14 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index f334104a..6d695445 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -104,6 +104,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * also work for calls of `set()`.
      *
      * @function
+     * @return {Point}
      */
     set: '#initialize',
 
@@ -183,7 +184,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * Attempts to apply the matrix to the content of item that it belongs to,
      * meaning its transformation is baked into the item's content or children.
      *
-     * @param {Boolean} recursively controls whether to apply transformations
+     * @param {Boolean} [recursively=true] controls whether to apply transformations
      * recursively on children
      * @return {Boolean} {@true if the matrix was applied}
      */
@@ -449,7 +450,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
     /**
      * Returns a new matrix as the result of prepending the specified matrix
      * to this matrix. This is the equivalent of multiplying
-     * `(specified matrix) s* (this matrix)`.
+     * `(specified matrix) * (this matrix)`.
      *
      * @param {Matrix} matrix the matrix to prepend
      * @return {Matrix} the newly created matrix
@@ -498,15 +499,15 @@ var Matrix = Base.extend(/** @lends Matrix# */{
     },
 
     /**
-     * @deprecated use use {@link #append(matrix)} instead.
+     * @deprecated use {@link #append(matrix)} instead.
      */
     concatenate: '#append',
     /**
-     * @deprecated use use {@link #prepend(matrix)} instead.
+     * @deprecated use {@link #prepend(matrix)} instead.
      */
     preConcatenate: '#prepend',
     /**
-     * @deprecated use use {@link #appended(matrix)} instead.
+     * @deprecated use {@link #appended(matrix)} instead.
      */
     chain: '#appended',
 
@@ -644,6 +645,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * Inverse transforms a point and returns the result.
      *
      * @param {Point} point the point to be transformed
+     * @return {Point}
      */
     inverseTransform: function(/* point */) {
         return this._inverseTransform(Point.read(arguments));
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 6bea5a7c..066be97a 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -170,6 +170,7 @@ var Point = Base.extend(/** @lends Point# */{
      * for calls of `set()`.
      *
      * @function
+     * @return {Point}
      */
     set: '#initialize',
 
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index cf7a804c..72f93dff 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -73,7 +73,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * Creates a new rectangle object from the passed rectangle object.
      *
      * @name Rectangle#initialize
-     * @param {Rectangle} rt
+     * @param {Rectangle} rectangle
      */
     initialize: function Rectangle(arg0, arg1, arg2, arg3) {
         var type = typeof arg0,
@@ -159,6 +159,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * constructors also work for calls of `set()`.
      *
      * @function
+     * @return {Rectangle}
      */
     set: '#initialize',
 
@@ -201,6 +202,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
 
     /**
      * Returns a copy of the rectangle.
+     * @return {Rectangle}
      */
     clone: function() {
         return new Rectangle(this.x, this.y, this.width, this.height);
diff --git a/src/basic/Size.js b/src/basic/Size.js
index b57ec6a2..219528ab 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -130,6 +130,7 @@ var Size = Base.extend(/** @lends Size# */{
      * for calls of `set()`.
      *
      * @function
+     * @return {Size}
      */
     set: '#initialize',
 
@@ -158,7 +159,7 @@ var Size = Base.extend(/** @lends Size# */{
      * Checks whether the width and height of the size are equal to those of the
      * supplied size.
      *
-     * @param {Size}
+     * @param {Size} size the size to compare to
      * @return {Boolean}
      *
      * @example
@@ -176,6 +177,7 @@ var Size = Base.extend(/** @lends Size# */{
 
     /**
      * Returns a copy of the size.
+     * @return {Size}
      */
     clone: function() {
         return new Size(this.width, this.height);
diff --git a/src/item/Item.js b/src/item/Item.js
index dda67647..d3a8d587 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1799,6 +1799,7 @@ new function() { // Injection scope for various item event handlers
      * }
      *
      * @param {Point} point the point to check for
+     * @return {Boolean}
      */
     contains: function(/* point */) {
         // See CompoundPath#_contains() for the reason for !!
@@ -2345,6 +2346,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * items can have children.
      *
      * @param {String} json the JSON data to import from
+     * @return {Item}
      */
     importJSON: function(json) {
         // Try importing into `this`. If another item is returned, try adding
@@ -2380,7 +2382,8 @@ new function() { // Injection scope for hit-test functions shared with project
      *     kept as a link to their external URL.
      *
      * @param {Object} [options] the export options
-     * @return {SVGElement} the item converted to an SVG node
+     * @return {SVGElement|String} the item converted to an SVG node or a
+     * `String` depending on `option.asString` value
      */
 
     /**
@@ -2764,6 +2767,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * Replaces this item with the provided new item which will takes its place
      * in the project hierarchy instead.
      *
+     * @param {Item} item the item that will replace this item
      * @return {Boolean} {@true if the item was replaced}
      */
     replaceWith: function(item) {
@@ -3186,7 +3190,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#dashArray
      * @property
-     * @type Array
+     * @type Number[]
      * @default []
      */
 
diff --git a/src/item/Project.js b/src/item/Project.js
index 8f16e7b9..810890a0 100644
--- a/src/item/Project.js
+++ b/src/item/Project.js
@@ -348,7 +348,7 @@ var Project = PaperScopeItem.extend(/** @lends Project# */{
      * {@link #layers} list.
      *
      * @param {Number} index the index at which to insert the layer
-     * @param {Item} item the item to be inserted in the project
+     * @param {Layer} layer the layer to be inserted in the project
      * @return {Layer} the added layer, or `null` if adding was not possible
      */
     insertLayer: function(index, layer) {
@@ -745,6 +745,7 @@ var Project = PaperScopeItem.extend(/** @lends Project# */{
      * {@link Project#clear()} to do so.
      *
      * @param {String} json the JSON data to import from
+     * @return {Item} the imported item
      */
     importJSON: function(json) {
         this.activate();
@@ -781,7 +782,8 @@ var Project = PaperScopeItem.extend(/** @lends Project# */{
      *     kept as a link to their external URL.
      *
      * @param {Object} [options] the export options
-     * @return {SVGElement} the project converted to an SVG node
+     * @return {SVGElement|String} the project converted to an SVG node or a
+     * `String` depending on `option.asString` value
      */
 
     /**
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 26256a07..39066a3f 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -463,7 +463,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      * @param {Rectangle} rect the boundaries of the sub image in pixel
      * coordinates
      *
-     * @return {HTMLCanvasELement} the sub image as a Canvas object
+     * @return {HTMLCanvasElement} the sub image as a Canvas object
      */
     getSubCanvas: function(/* rect */) {
         var rect = Rectangle.read(arguments),
@@ -511,7 +511,7 @@ var Raster = Item.extend(/** @lends Raster# */{
     /**
      * Draws an image on the raster.
      *
-     * @param {HTMLImageELement|HTMLCanvasELement} image
+     * @param {HTMLImageElement|HTMLCanvasElement} image
      * @param {Point} point the offset of the image as a point in pixel
      * coordinates
      */
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 0f84beb3..0d2beef2 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -31,7 +31,9 @@ var SymbolItem = Item.extend(/** @lends SymbolItem# */{
     /**
      * Creates a new symbol item.
      *
-     * @param {Item} definition the symbol definition to place
+     * @name SymbolItem#initialize
+     * @param {SymbolDefinition|Item} definition the definition to place or an
+     *     item to place as a symbol
      * @param {Point} [point] the center point of the placed symbol
      *
      * @example {@paperscript split=true height=240}
diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 309c5d99..a6e6c752 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -147,7 +147,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
      * The path that this locations is situated on.
      *
      * @bean
-     * @type Item
+     * @type Path
      */
     getPath: function() {
         var curve = this.getCurve();
diff --git a/src/path/Path.js b/src/path/Path.js
index 311ffc1e..513942cd 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -1214,6 +1214,8 @@ var Path = PathItem.extend(/** @lends Path# */{
     /**
      * Reduces the path by removing curves that have a length of 0,
      * and unnecessary segments between two collinear flat curves.
+     *
+     * @return {Path} the reduced path
      */
     reduce: function(options) {
         var curves = this.getCurves(),
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index d0e9a51d..41f6d736 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -345,6 +345,8 @@ var PathItem = Item.extend(/** @lends PathItem# */{
      * crossing each other, as opposed to simply touching.
      *
      * @param {PathItem} path the other item to find the crossings with
+     * @return {CurveLocation[]} the locations of all crossings between the
+     *     paths
      * @see #getIntersections(path)
      */
     getCrossings: function(path) {
diff --git a/src/path/Segment.js b/src/path/Segment.js
index 5a732f3a..28cd5301 100644
--- a/src/path/Segment.js
+++ b/src/path/Segment.js
@@ -554,6 +554,9 @@ var Segment = Base.extend(/** @lends Segment# */{
         return this._path ? !!this._path.removeSegment(this._index) : false;
     },
 
+    /**
+     * @return {Segment}
+     */
     clone: function() {
         return new Segment(this._point, this._handleIn, this._handleOut);
     },
diff --git a/src/style/Color.js b/src/style/Color.js
index dcfb079e..86c0765c 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -691,6 +691,7 @@ var Color = Base.extend(new function() {
          * constructors also work for calls of `set()`.
          *
          * @function
+         * @return {Color}
          */
         set: '#initialize',
 
diff --git a/src/style/Style.js b/src/style/Style.js
index 6b90885a..a149c00d 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -536,7 +536,7 @@ var Style = Base.extend(new function() {
      *
      * @name Style#dashArray
      * @property
-     * @type Array
+     * @type Number[]
      * @default []
      */
 

From b1705f628b829fe296d8191adbb8016fea09dc49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 21 Nov 2018 11:58:22 +0100
Subject: [PATCH 027/181] Fix typos

---
 package.json            | 5 ++++-
 src/core/PaperScript.js | 2 +-
 src/view/CanvasView.js  | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index a1400798..4b7f05ae 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,10 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
+  "contributors": [
+    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
+    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
+  ],
   "main": "dist/paper-full.js",
   "scripts": {
     "precommit": "gulp jshint --branch develop",
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index f42b76ff..fbe88800 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -177,7 +177,7 @@ Base.exports.PaperScript = function() {
             var start = getOffset(node.range[0]),
                 end = getOffset(node.range[1]),
                 insert = 0;
-            // Sort insertions by their offset, so getOffest() can do its thing
+            // Sort insertions by their offset, so getOffset() can do its thing
             for (var i = insertions.length - 1; i >= 0; i--) {
                 if (start > insertions[i][0]) {
                     insert = i + 1;
diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index efc120bb..b783eeb0 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -124,7 +124,7 @@ var CanvasView = View.extend(/** @lends CanvasView# */{
 
     /**
      * Updates the view if there are changes. Note that when using built-in
-     * event hanlders for interaction, animation and load events, this method is
+     * event handlers for interaction, animation and load events, this method is
      * invoked for you automatically at the end.
      *
      * @return {Boolean} {@true if the view was updated}

From d46b6cbef4ff01e6cd25e58096769c6a10f9c24e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 28 Nov 2018 11:40:17 +0100
Subject: [PATCH 028/181] Fix Emitter.once()

---
 src/core/Emitter.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/Emitter.js b/src/core/Emitter.js
index 44e5e81c..6ecb482a 100644
--- a/src/core/Emitter.js
+++ b/src/core/Emitter.js
@@ -68,9 +68,9 @@ var Emitter = {
     },
 
     once: function(type, func) {
-        return this.on(type, function() {
+        return this.on(type, function handler() {
             func.apply(this, arguments);
-            this.off(type, func);
+            this.off(type, handler);
         });
     },
 

From 684f5049302cfefd4137e108cb38c33c70594ad0 Mon Sep 17 00:00:00 2001
From: arnoson <omasocke@hotmail.de>
Date: Wed, 28 Nov 2018 20:26:25 +0100
Subject: [PATCH 029/181] Implement tweening

---
 src/core/PaperScript.js |   4 +-
 src/item/Item.js        | 155 ++++++++++++++++++++-
 src/item/Tween.js       | 301 ++++++++++++++++++++++++++++++++++++++++
 src/paper.js            |   1 +
 4 files changed, 459 insertions(+), 2 deletions(-)
 create mode 100644 src/item/Tween.js

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index fbe88800..e64ef2a7 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -657,7 +657,9 @@ Base.exports.PaperScript = function() {
         compile: compile,
         execute: execute,
         load: load,
-        parse: parse
+        parse: parse,
+        calculateBinary: __$__,
+        calculateUnary: $__
     };
 // Pass on `this` as the binding object, so we can reference Acorn both in
 // development and in the built library.
diff --git a/src/item/Item.js b/src/item/Item.js
index d3a8d587..e9e4b69d 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4667,4 +4667,157 @@ new function() { // Injection scope for hit-test functions shared with project
         }
         return this;
     }
-}));
+}), /** @lends Item# */{
+    /**
+     * {@grouptitle Tweening Functions}
+     *
+     * Tween item between two states
+     *
+     * @name Item#tween
+     *
+     * @option options.duration {Number} the duration of the tweening
+     * @option options.easing {Function|String} an easing function or the type
+     * of the easing: {@values 'linear' 'easeInQuad' 'easeOutQuad'
+     * 'easeInOutQuad' 'easeInCubic' 'easeOutCubic' 'easeInOutCubic'
+     * 'easeInQuart' 'easeOutQuart' 'easeInOutQuart' 'easeInQuint'
+     * 'easeOutQuint' 'easeInOutQuint'}
+     * @option options.start {Boolean} Whether to start tweening automatically
+     *
+     * @function
+     * @param {Object} from the state at the start of the tweening
+     * @param {Object} to the state at the end of the tweening
+     * @param {Object|Number} options the options or the duration
+     * @return {Tween}
+     *
+     * @example {@paperscript height=100}
+     * // Tween fillColor:
+     * var path = new Path.Circle({
+     *     radius: view.bounds.height * 0.4,
+     *     center: view.center
+     * })
+     * path.tween({ fillColor: 'blue' }, { fillColor: 'red' }, 3000)
+     */
+    /**
+     * Tween item to a state
+     *
+     * @name Item#tween
+     *
+     * @function
+     * @param  {Object} to the state at the end of the tweening
+     * @param  {Object|Number} options or duration
+     * @return {Tween}
+     *
+     * @example {@paperscript height=200}
+     * // Tween a nested property with relative values
+     * var path = new Path.Rectangle({
+     *     size: [100, 100],
+     *     position: view.center,
+     *     fillColor: 'red',
+     * })
+     *
+     * var delta = { x: path.bounds.width / 2, y: 0 }
+     *
+     * path.tweenTo({
+     *     'segments[1].point': ['+=', delta],
+     *     'segments[2].point.x': '-= 50'
+     * }, 3000)
+     *
+     * @see Item#tween(from, to, options)
+     */
+    /**
+     * Tween item
+     *
+     * @name Item#tween
+     *
+     * @function
+     * @param  {Object|Number} options options or duration
+     * @return {Tween}
+     *
+     * @see Item#tween(from, to, options)
+     *
+     * @example {@paperscript height=100}
+     * // Start an empty tween and just use the update callback:
+     * var path = new Path.Circle({
+     *     fillColor: 'blue',
+     *     radius: view.bounds.height * 0.4,
+     *     center: view.center,
+     * })
+     * var pathFrom = path.clone({ insert: false })
+     * var pathTo = new Path.Rectangle({
+     *     position: view.center,
+     *     rectangle: path.bounds,
+     *     insert: false
+     * })
+     * path.tween(2000).on('update', function(event) {
+     *     path.interpolate(pathFrom, pathTo, event.factor)
+     * })
+     */
+    tween: function(from, to, options) {
+        if (!options) {
+            // If there are only two or one arguments, shift arguments to the
+            // left by one (omit `from`):
+            options = to;
+            to = from;
+            from = null;
+            if (!options) {
+                options = to;
+                to = null;
+            }
+        }
+        var easing = options && options.easing,
+            start = options && options.start,
+            duration = options != null && (
+                typeof options === 'number' ? options : options.duration
+            ),
+            tween = new Tween(this, from, to, duration, easing, start);
+        function onFrame(event) {
+            tween.handleFrame(event.time * 1000);
+            if (!tween.running) {
+                this.off('frame', onFrame);
+            }
+        }
+        if (duration) {
+            this.on('frame', onFrame);
+        }
+        return tween;
+    },
+
+    /**
+     *
+     * Tween item to a state
+     *
+     * @function
+     * @param {Object} state the state at the end of the tweening
+     * @param {Object|Number} options the options or the duration
+     * @return {Tween}
+     *
+     * @see Item#tween(to, options)
+     */
+    tweenTo: function(state, options) {
+        return this.tween(null, state, options);
+    },
+
+    /**
+     *
+     * Tween from a state to it's state before the tweening
+     *
+     * @function
+     * @param {Object} state the state at the end of the tweening
+     * @param {Object|Number} options the options or the duration
+     * @return {Tween}
+     *
+     * @see Item#tween(from, to, options)
+     *
+     * @example {@paperscript height=100}
+     * // Tween fillColor from red to the path's initial fillColor:
+     * var path = new Path.Circle({
+     *     fillColor: 'blue',
+     *     radius: view.bounds.height * 0.4,
+     *     center: view.center
+     * })
+     * path.tweenFrom({ fillColor: 'blue' }, { duration: 1000 })
+     */
+    tweenFrom: function(state, options) {
+        return this.tween(state, null, options);
+    }
+});
diff --git a/src/item/Tween.js b/src/item/Tween.js
new file mode 100644
index 00000000..63d9cbf8
--- /dev/null
+++ b/src/item/Tween.js
@@ -0,0 +1,301 @@
+/*
+ * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ */
+
+/**
+ * @name Tween
+ *
+ * @class Allows to tween properties of an Item between two values
+ */
+var Tween = Base.extend(Emitter, /** @lends Tween# */{
+    _class: 'Tween',
+
+    statics: {
+        easings: {
+            // no easing, no acceleration
+            linear: function(t) {
+                return t;
+            },
+
+            // accelerating from zero velocity
+            easeInQuad: function(t) {
+                return t * t;
+            },
+
+            // decelerating to zero velocity
+            easeOutQuad: function(t) {
+                return t * (2 - t);
+            },
+
+            // acceleration until halfway, then deceleration
+            easeInOutQuad: function(t) {
+                return t < 0.5
+                    ? 2 * t * t
+                    : -1 + 2 * (2 - t) * t;
+            },
+
+            // accelerating from zero velocity
+            easeInCubic: function(t) {
+                return t * t * t;
+            },
+
+            // decelerating to zero velocity
+            easeOutCubic: function(t) {
+                return --t * t * t + 1;
+            },
+
+            // acceleration until halfway, then deceleration
+            easeInOutCubic: function(t) {
+                return t < 0.5
+                    ? 4 * t * t * t
+                    : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+            },
+
+            // accelerating from zero velocity
+            easeInQuart: function(t) {
+                return t * t * t * t;
+            },
+
+            // decelerating to zero velocity
+            easeOutQuart: function(t) {
+                return 1 - (--t) * t * t * t;
+            },
+
+            // acceleration until halfway, then deceleration
+            easeInOutQuart: function(t) {
+                return t < 0.5
+                    ? 8 * t * t * t * t
+                    : 1 - 8 * (--t) * t * t * t;
+            },
+
+            // accelerating from zero velocity
+            easeInQuint: function(t) {
+                return t * t * t * t * t;
+            },
+
+            // decelerating to zero velocity
+            easeOutQuint: function(t) {
+                return 1 + --t * t * t * t * t;
+            },
+
+            // acceleration until halfway, then deceleration
+            easeInOutQuint: function(t) {
+                return t < 0.5
+                    ? 16 * t * t * t * t * t
+                    : 1 + 16 * (--t) * t * t * t * t;
+            }
+        }
+    },
+
+    /**
+     * {@grouptitle Event Handling}
+     *
+     * Attaches an event handler to the tween.
+     *
+     * @name Tween#on
+     * @function
+     * @param {String} type the type of event (currently only 'update')
+     * @param {Function} function the function to be called when the event
+     *     occurs, receiving an object as its
+     *     sole argument, containing the current progress of the
+     *     tweening and the factor calculated by the easing function
+     * @return {Tween} this tween itself, so calls can be chained
+     */
+    /**
+     * Creates a new tween
+     *
+     * @name Path#initialize
+     * @param {Item} item The Item to be tweened
+     * @param {Object} from State at the start of the tweening
+     * @param {Object} to State at the end of the tweening
+     * @param {Number} duration Duration of the tweening
+     * @param {String|Function} easing Type of the easing function or the easing
+     * function
+     * @param {Boolean} start Whether to start tweening automatically
+     * @return {Tween} the newly created tween
+     */
+    initialize: function Tween(item, from, to, duration, easing, start) {
+        this.item = item;
+        var type = typeof easing
+        var isFunction = type === 'function';
+        this.type = isFunction
+            ? type
+            : type === 'string'
+                ? easing
+                : 'linear';
+        this.easing = isFunction ? easing : Tween.easings[this.type];
+        this.duration = duration;
+        this.running = false;
+
+        this._then = null;
+        this._startTime = null;
+        var state = from || to;
+        this._keys = state ? Object.keys(state) : [];
+        this._parsedKeys = this._parseKeys(this._keys);
+        this._from = state && this._getState(from);
+        this._to = state && this._getState(to);
+        if (start !== false) {
+          this.start();
+        }
+    },
+
+    handleFrame: function(time) {
+        var startTime = this._startTime,
+            progress = startTime
+                ? (time - startTime) / this.duration
+                : 0;
+        if (!startTime) {
+            this._startTime = time;
+        }
+        this.update(progress);
+    },
+
+    then: function(then) {
+        this._then = then;
+        return this;
+    },
+
+    start: function() {
+        this._startTime = null;
+        this.running = true;
+        return this;
+    },
+
+    stop: function() {
+        this.running = false;
+        return this;
+    },
+
+    update: function(progress) {
+        if (this.running) {
+            if (progress > 1) {
+                // always finish the animation
+                progress = 1;
+                this.running = false;
+            }
+
+            var factor = this.easing(progress),
+                keys = this._keys,
+                getValue = function(value) {
+                    return typeof value === 'function'
+                        ? value(factor, progress)
+                        : value;
+                };
+            for (var i = 0, l = keys && keys.length; i < l; i++) {
+                var key = keys[i],
+                    from = getValue(this._from[key]),
+                    to = getValue(this._to[key]),
+                    // Some paper objects have math functions (e.g.: Point,
+                    // Color) which can directly be used to do the tweening.
+                    value = (from && to && from.__add && to.__add)
+                        ? to.__subtract(from).__multiply(factor).__add(from)
+                        : ((to - from) * factor) + from;
+                this._setItemProperty(this._parsedKeys[key], value);
+            }
+
+            if (!this.running && this._then) {
+                this._then(this.item);
+            }
+            if (this.responds('update')) {
+                this.emit('update', new Base({
+                    progress: progress,
+                    factor: factor
+                }));
+            }
+        }
+        return this;
+    },
+
+    _getState: function(state) {
+        var keys = this._keys,
+            result = {};
+        for (var i = 0, l = keys.length; i < l; i++) {
+            var key = keys[i],
+                path = this._parsedKeys[key],
+                current = this._getItemProperty(path),
+                value;
+            if (state) {
+                var resolved = this._resolveValue(current, state[key]);
+                // Temporarily set the resolved value, so we can retrieve the
+                // coerced value from paper's internal magic.
+                this._setItemProperty(path, resolved);
+                value = this._getItemProperty(path);
+                // Clone the value if possible to prevent future changes.
+                value = value.clone ? value.clone() : value
+                this._setItemProperty(path, current);
+            } else {
+                // We want to get the current state at the time of the call, so
+                // we have to clone if possible to prevent future changes.
+                value = current.clone ? current.clone() : current;
+            }
+            result[key] = value;
+        }
+        return result;
+    },
+
+    _resolveValue: function(current, value) {
+        if (value) {
+            if (Array.isArray(value) && value.length === 2) {
+                var operator = value[0];
+                return (
+                    operator &&
+                    operator.match &&
+                    operator.match(/^[+\-*/]=/)
+                )
+                    ? this._calculate(current, operator[0], value[1])
+                    : value;
+            } else if (typeof value === 'string') {
+                var match = value.match(/^[+\-*/]=(.*)/);
+                if (match) {
+                    var parsed = JSON.parse(match[1].replace(
+                        /(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+                        '"$2": '
+                    ));
+                    return this._calculate(current, value[0], parsed);
+                }
+            }
+        }
+        return value;
+    },
+
+    _calculate: function(left, operator, right) {
+        return paper.PaperScript.calculateBinary(left, operator, right);
+    },
+
+    _parseKeys: function(keys) {
+        var parsed = {};
+        for (var i = 0, l = keys.length; i < l; i++) {
+            var key = keys[i],
+                path = key
+                    // Convert from JS property access notation to JSON pointer:
+                    .replace(/\.([^.]*)/g, '/$1')
+                    // Expand array property access notation ([])
+                    .replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+            parsed[key] = path.split('/');
+        }
+        return parsed;
+    },
+
+    _getItemProperty: function(path, offset) {
+        var obj = this.item;
+        for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+            obj = obj[path[i]];
+        }
+        return obj;
+    },
+
+    _setItemProperty: function(path, value) {
+        var dest = this._getItemProperty(path, 1);
+        if (dest) {
+            dest[path[path.length - 1]] = value;
+        }
+    }
+});
diff --git a/src/paper.js b/src/paper.js
index 0fcf9ff1..1f5c153f 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -65,6 +65,7 @@ var paper = function(self, undefined) {
 /*#*/ include('item/SymbolItem.js');
 /*#*/ include('item/SymbolDefinition.js');
 /*#*/ include('item/HitResult.js');
+/*#*/ include('item/Tween.js');
 
 /*#*/ include('path/Segment.js');
 /*#*/ include('path/SegmentPoint.js');

From e52a33b9cbe635ab849e1d6252ab72423c4edb45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 29 Nov 2018 14:10:08 +0100
Subject: [PATCH 030/181] Fix linting errors

---
 src/item/Tween.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/item/Tween.js b/src/item/Tween.js
index 63d9cbf8..ccee3d29 100644
--- a/src/item/Tween.js
+++ b/src/item/Tween.js
@@ -124,7 +124,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      */
     initialize: function Tween(item, from, to, duration, easing, start) {
         this.item = item;
-        var type = typeof easing
+        var type = typeof easing;
         var isFunction = type === 'function';
         this.type = isFunction
             ? type
@@ -229,7 +229,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
                 this._setItemProperty(path, resolved);
                 value = this._getItemProperty(path);
                 // Clone the value if possible to prevent future changes.
-                value = value.clone ? value.clone() : value
+                value = value.clone ? value.clone() : value;
                 this._setItemProperty(path, current);
             } else {
                 // We want to get the current state at the time of the call, so

From 266cf365f585b44e63d82f28e2cc73c58f8c1793 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 30 Nov 2018 11:50:10 +0100
Subject: [PATCH 031/181] Fix `Item#tween()` documentation.

---
 src/item/Item.js | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index e9e4b69d..660d08c6 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4671,17 +4671,17 @@ new function() { // Injection scope for hit-test functions shared with project
     /**
      * {@grouptitle Tweening Functions}
      *
-     * Tween item between two states
+     * Tween item between two states.
      *
      * @name Item#tween
      *
      * @option options.duration {Number} the duration of the tweening
-     * @option options.easing {Function|String} an easing function or the type
+     * @option [options.easing='linear'] {Function|String} an easing function or the type
      * of the easing: {@values 'linear' 'easeInQuad' 'easeOutQuad'
      * 'easeInOutQuad' 'easeInCubic' 'easeOutCubic' 'easeInOutCubic'
      * 'easeInQuart' 'easeOutQuart' 'easeInOutQuart' 'easeInQuint'
      * 'easeOutQuint' 'easeInOutQuint'}
-     * @option options.start {Boolean} Whether to start tweening automatically
+     * @option [options.start=true] {Boolean} whether to start tweening automatically
      *
      * @function
      * @param {Object} from the state at the start of the tweening
@@ -4698,13 +4698,13 @@ new function() { // Injection scope for hit-test functions shared with project
      * path.tween({ fillColor: 'blue' }, { fillColor: 'red' }, 3000)
      */
     /**
-     * Tween item to a state
+     * Tween item to a state.
      *
      * @name Item#tween
      *
      * @function
      * @param  {Object} to the state at the end of the tweening
-     * @param  {Object|Number} options or duration
+     * @param {Object|Number} options the options or the duration
      * @return {Tween}
      *
      * @example {@paperscript height=200}
@@ -4717,7 +4717,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * var delta = { x: path.bounds.width / 2, y: 0 }
      *
-     * path.tweenTo({
+     * path.tween({
      *     'segments[1].point': ['+=', delta],
      *     'segments[2].point.x': '-= 50'
      * }, 3000)
@@ -4725,12 +4725,12 @@ new function() { // Injection scope for hit-test functions shared with project
      * @see Item#tween(from, to, options)
      */
     /**
-     * Tween item
+     * Tween item.
      *
      * @name Item#tween
      *
      * @function
-     * @param  {Object|Number} options options or duration
+     * @param  {Object|Number} options the options or the duration
      * @return {Tween}
      *
      * @see Item#tween(from, to, options)
@@ -4784,7 +4784,7 @@ new function() { // Injection scope for hit-test functions shared with project
 
     /**
      *
-     * Tween item to a state
+     * Tween item to a state.
      *
      * @function
      * @param {Object} state the state at the end of the tweening
@@ -4799,10 +4799,10 @@ new function() { // Injection scope for hit-test functions shared with project
 
     /**
      *
-     * Tween from a state to it's state before the tweening
+     * Tween item from a state to its state before the tweening.
      *
      * @function
-     * @param {Object} state the state at the end of the tweening
+     * @param {Object} state the state at the start of the tweening
      * @param {Object|Number} options the options or the duration
      * @return {Tween}
      *
@@ -4811,7 +4811,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * @example {@paperscript height=100}
      * // Tween fillColor from red to the path's initial fillColor:
      * var path = new Path.Circle({
-     *     fillColor: 'blue',
+     *     fillColor: 'red',
      *     radius: view.bounds.height * 0.4,
      *     center: view.center
      * })

From f2b6e67bcbfff8d52152cba64a5064ac63a69574 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 30 Nov 2018 12:07:01 +0100
Subject: [PATCH 032/181] Fix `Item#tweenFrom()` documentation example.

Example code was not matching example title.
---
 src/item/Item.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 660d08c6..429646ab 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4811,11 +4811,11 @@ new function() { // Injection scope for hit-test functions shared with project
      * @example {@paperscript height=100}
      * // Tween fillColor from red to the path's initial fillColor:
      * var path = new Path.Circle({
-     *     fillColor: 'red',
+     *     fillColor: 'blue',
      *     radius: view.bounds.height * 0.4,
      *     center: view.center
      * })
-     * path.tweenFrom({ fillColor: 'blue' }, { duration: 1000 })
+     * path.tweenFrom({ fillColor: 'red' }, { duration: 1000 })
      */
     tweenFrom: function(state, options) {
         return this.tween(state, null, options);

From 6d411e9b7f2f1584125145ace3b209f01993bac8 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 30 Nov 2018 15:10:31 +0100
Subject: [PATCH 033/181] Add Tween documentation

---
 src/item/Tween.js | 126 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 101 insertions(+), 25 deletions(-)

diff --git a/src/item/Tween.js b/src/item/Tween.js
index ccee3d29..91817ae6 100644
--- a/src/item/Tween.js
+++ b/src/item/Tween.js
@@ -13,7 +13,8 @@
 /**
  * @name Tween
  *
- * @class Allows to tween properties of an Item between two values
+ * @class Allows tweening {@link Item} properties between two states for a given
+ * duration. Tween instance is returned by {@link Item#tween(from,to,options)}.
  */
 var Tween = Base.extend(Emitter, /** @lends Tween# */{
     _class: 'Tween',
@@ -96,30 +97,15 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
     },
 
     /**
-     * {@grouptitle Event Handling}
+     * Creates a new tween.
      *
-     * Attaches an event handler to the tween.
-     *
-     * @name Tween#on
-     * @function
-     * @param {String} type the type of event (currently only 'update')
-     * @param {Function} function the function to be called when the event
-     *     occurs, receiving an object as its
-     *     sole argument, containing the current progress of the
-     *     tweening and the factor calculated by the easing function
-     * @return {Tween} this tween itself, so calls can be chained
-     */
-    /**
-     * Creates a new tween
-     *
-     * @name Path#initialize
-     * @param {Item} item The Item to be tweened
-     * @param {Object} from State at the start of the tweening
-     * @param {Object} to State at the end of the tweening
-     * @param {Number} duration Duration of the tweening
-     * @param {String|Function} easing Type of the easing function or the easing
-     * function
-     * @param {Boolean} start Whether to start tweening automatically
+     * @param {Item} item the item to tween
+     * @param {Object} from the state at the start of the tweening
+     * @param {Object} to the state at the end of the tweening
+     * @param {Number} duration the duration of the tweening
+     * @param {String|Function} [easing='linear'] the type of the easing
+     *     function or the easing function
+     * @param {Boolean} [start=true] whether to start tweening automatically
      * @return {Tween} the newly created tween
      */
     initialize: function Tween(item, from, to, duration, easing, start) {
@@ -143,7 +129,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         this._from = state && this._getState(from);
         this._to = state && this._getState(to);
         if (start !== false) {
-          this.start();
+            this.start();
         }
     },
 
@@ -158,17 +144,73 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         this.update(progress);
     },
 
+    /**
+     * Set a function that will be executed when tween completes.
+     * @param {Function} function the function to execute when tween completes
+     * @return {Tween}
+     *
+     * @example {@paperscript}
+     * // Tweens chaining:
+     * var item = new Path.Circle({
+     *     center: view.center,
+     *     radius: 50,
+     *     fillColor: 'blue'
+     * });
+     * // Tween color from blue to red.
+     * var tween = item.tweenTo({fillColor: 'red'}, 2000);
+     * // When first tween completes...
+     * tween.then(function(){
+     *     // ...tween color back to blue.
+     *     item.tweenTo({fillColor: 'blue'}, 2000);
+     * });
+     */
     then: function(then) {
         this._then = then;
         return this;
     },
 
+    /**
+     * Start tweening.
+     * @return {Tween}
+     *
+     * @example {@paperscript}
+     * // Manually start tweening.
+     * var item = new Path.Circle({
+     *     center: view.center,
+     *     radius: 50,
+     *     fillColor: 'blue'
+     * });
+     * var tween = item.tweenTo(
+     *     { fillColor: 'red' },
+     *     { duration: 2000, start: false }
+     * );
+     * tween.start();
+     */
     start: function() {
         this._startTime = null;
         this.running = true;
         return this;
     },
 
+    /**
+     * Stop tweening.
+     * @return {Tween}
+     *
+     * @example {@paperscript}
+     * // Stop a tween before it completes.
+     * var item = new Path.Circle({
+     *     center: view.center,
+     *     radius: 50,
+     *     fillColor: 'blue'
+     * });
+     * // Start tweening from blue to red for 2 seconds.
+     * var tween = item.tweenTo({ fillColor: 'red' }, 2000);
+     * // After 1 second...
+     * setTimeout(function(){
+     *     // ...stop tweening.
+     *     tween.stop();
+     * }, 1000);
+     */
     stop: function() {
         this.running = false;
         return this;
@@ -214,6 +256,40 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         return this;
     },
 
+    /**
+     * {@grouptitle Event Handling}
+     *
+     * Attaches an event handler to the tween.
+     *
+     * @name Tween#on
+     * @function
+     * @param {String} type the type of event (currently only 'update')
+     * @param {Function} function the function to be called when the event
+     *     occurs, receiving an object as its
+     *     sole argument, containing the current progress of the
+     *     tweening and the factor calculated by the easing function
+     * @return {Tween} this tween itself, so calls can be chained
+     *
+     *
+     * @example {@paperscript}
+     * // Display tween progression values:
+     * var item = new Path.Circle({
+     *     center: view.center,
+     *     radius: 50,
+     *     fillColor: 'blue'
+     * });
+     * var tween = item.tweenTo(
+     *     { fillColor: 'red' },
+     *     { duration: 2000, easing: 'easeInCubic' }
+     * );
+     * var progressText = new PointText(view.center + [60, -10]);
+     * var factorText = new PointText(view.center + [60, 10]);
+     * tween.on('update', function(event) {
+     *     progressText.content = 'progress: ' + event.progress.toFixed(2);
+     *     factorText.content = 'factor: ' + event.factor.toFixed(2);
+     * });
+     */
+
     _getState: function(state) {
         var keys = this._keys,
             result = {};

From a97382d1c58b3a0df6546a0eb187627cdb962160 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 3 Dec 2018 09:44:37 +0100
Subject: [PATCH 034/181] Document tween update event as `Tween#onUpdate`.

---
 src/item/Item.js  | 22 +++++++++++-----------
 src/item/Tween.js | 25 ++++++++++++-------------
 2 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 429646ab..65e24f70 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4694,8 +4694,8 @@ new function() { // Injection scope for hit-test functions shared with project
      * var path = new Path.Circle({
      *     radius: view.bounds.height * 0.4,
      *     center: view.center
-     * })
-     * path.tween({ fillColor: 'blue' }, { fillColor: 'red' }, 3000)
+     * });
+     * path.tween({ fillColor: 'blue' }, { fillColor: 'red' }, 3000);
      */
     /**
      * Tween item to a state.
@@ -4713,14 +4713,14 @@ new function() { // Injection scope for hit-test functions shared with project
      *     size: [100, 100],
      *     position: view.center,
      *     fillColor: 'red',
-     * })
+     * });
      *
-     * var delta = { x: path.bounds.width / 2, y: 0 }
+     * var delta = { x: path.bounds.width / 2, y: 0 };
      *
      * path.tween({
      *     'segments[1].point': ['+=', delta],
      *     'segments[2].point.x': '-= 50'
-     * }, 3000)
+     * }, 3000);
      *
      * @see Item#tween(from, to, options)
      */
@@ -4741,16 +4741,16 @@ new function() { // Injection scope for hit-test functions shared with project
      *     fillColor: 'blue',
      *     radius: view.bounds.height * 0.4,
      *     center: view.center,
-     * })
+     * });
      * var pathFrom = path.clone({ insert: false })
      * var pathTo = new Path.Rectangle({
      *     position: view.center,
      *     rectangle: path.bounds,
      *     insert: false
-     * })
-     * path.tween(2000).on('update', function(event) {
+     * });
+     * path.tween(2000).onUpdate = function(event) {
      *     path.interpolate(pathFrom, pathTo, event.factor)
-     * })
+     * };
      */
     tween: function(from, to, options) {
         if (!options) {
@@ -4814,8 +4814,8 @@ new function() { // Injection scope for hit-test functions shared with project
      *     fillColor: 'blue',
      *     radius: view.bounds.height * 0.4,
      *     center: view.center
-     * })
-     * path.tweenFrom({ fillColor: 'red' }, { duration: 1000 })
+     * });
+     * path.tweenFrom({ fillColor: 'red' }, { duration: 1000 });
      */
     tweenFrom: function(state, options) {
         return this.tween(state, null, options);
diff --git a/src/item/Tween.js b/src/item/Tween.js
index 91817ae6..8dbd04c6 100644
--- a/src/item/Tween.js
+++ b/src/item/Tween.js
@@ -257,19 +257,15 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
     },
 
     /**
-     * {@grouptitle Event Handling}
+     * {@grouptitle Event Handlers}
      *
-     * Attaches an event handler to the tween.
-     *
-     * @name Tween#on
-     * @function
-     * @param {String} type the type of event (currently only 'update')
-     * @param {Function} function the function to be called when the event
-     *     occurs, receiving an object as its
-     *     sole argument, containing the current progress of the
-     *     tweening and the factor calculated by the easing function
-     * @return {Tween} this tween itself, so calls can be chained
+     * The function to be called when the tween is updated. It receives an
+     * object as its sole argument, containing the current progress of the
+     * tweening and the factor calculated by the easing function.
      *
+     * @name Tween#onUpdate
+     * @property
+     * @type Function
      *
      * @example {@paperscript}
      * // Display tween progression values:
@@ -284,11 +280,14 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      * );
      * var progressText = new PointText(view.center + [60, -10]);
      * var factorText = new PointText(view.center + [60, 10]);
-     * tween.on('update', function(event) {
+     * tween.onUpdate = function(event) {
      *     progressText.content = 'progress: ' + event.progress.toFixed(2);
      *     factorText.content = 'factor: ' + event.factor.toFixed(2);
-     * });
+     * };
      */
+    _events: {
+        onUpdate: {}
+    },
 
     _getState: function(state) {
         var keys = this._keys,

From 9c684091f42675043e0135ae31a4155b96901b5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 3 Dec 2018 12:51:31 +0100
Subject: [PATCH 035/181] Move Tween class to anim namespace + changes

- Change from item to object, as it can be used to tween any property on any object really
- Make _handleFrame() private
- Minor documentation tweaks
---
 gulp/jsdoc                  |   2 +-
 src/{item => anim}/Tween.js | 114 ++++++++++++++++++++----------------
 src/item/Item.js            |  31 +++++++---
 src/paper.js                |   3 +-
 4 files changed, 91 insertions(+), 59 deletions(-)
 rename src/{item => anim}/Tween.js (82%)

diff --git a/gulp/jsdoc b/gulp/jsdoc
index 2533ac8e..da249447 160000
--- a/gulp/jsdoc
+++ b/gulp/jsdoc
@@ -1 +1 @@
-Subproject commit 2533ac8e1863262f3c28cd29bc940c6d2ecdf147
+Subproject commit da249447ca037b67cad8193c59e8ce33fb40c61f
diff --git a/src/item/Tween.js b/src/anim/Tween.js
similarity index 82%
rename from src/item/Tween.js
rename to src/anim/Tween.js
index 8dbd04c6..d9655723 100644
--- a/src/item/Tween.js
+++ b/src/anim/Tween.js
@@ -13,8 +13,16 @@
 /**
  * @name Tween
  *
- * @class Allows tweening {@link Item} properties between two states for a given
- * duration. Tween instance is returned by {@link Item#tween(from,to,options)}.
+ * @class Allows tweening `Object` properties between two states for a given
+ * duration. To tween properties on Paper.js {@link Item} instances,
+ * {@link Item#tween(from, to, options)} can be used, which returns created
+ * tween instance.
+ *
+ * @see Item#tween(from, to, options)
+ * @see Item#tween(to, options)
+ * @see Item#tween(options)
+ * @see Item#tweenTo(to, options)
+ * @see Item#tweenFrom(from, options)
  */
 var Tween = Base.extend(Emitter, /** @lends Tween# */{
     _class: 'Tween',
@@ -99,7 +107,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
     /**
      * Creates a new tween.
      *
-     * @param {Item} item the item to tween
+     * @param {Object} object the object to tween the properties on
      * @param {Object} from the state at the start of the tweening
      * @param {Object} to the state at the end of the tweening
      * @param {Number} duration the duration of the tweening
@@ -108,8 +116,8 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      * @param {Boolean} [start=true] whether to start tweening automatically
      * @return {Tween} the newly created tween
      */
-    initialize: function Tween(item, from, to, duration, easing, start) {
-        this.item = item;
+    initialize: function Tween(object, from, to, duration, easing, start) {
+        this.object = object;
         var type = typeof easing;
         var isFunction = type === 'function';
         this.type = isFunction
@@ -133,35 +141,21 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         }
     },
 
-    handleFrame: function(time) {
-        var startTime = this._startTime,
-            progress = startTime
-                ? (time - startTime) / this.duration
-                : 0;
-        if (!startTime) {
-            this._startTime = time;
-        }
-        this.update(progress);
-    },
-
     /**
-     * Set a function that will be executed when tween completes.
-     * @param {Function} function the function to execute when tween completes
+     * Set a function that will be executed when the tween completes.
+     * @param {Function} function the function to execute when the tween
+     *     completes
      * @return {Tween}
      *
-     * @example {@paperscript}
-     * // Tweens chaining:
-     * var item = new Path.Circle({
-     *     center: view.center,
-     *     radius: 50,
-     *     fillColor: 'blue'
+     * @example {@paperscript} // Tweens chaining: var circle = new
+     * Path.Circle({center: view.center, radius: 50, fillColor: 'blue'
      * });
      * // Tween color from blue to red.
-     * var tween = item.tweenTo({fillColor: 'red'}, 2000);
-     * // When first tween completes...
-     * tween.then(function(){
+     * var tween = item.tweenTo({ fillColor: 'red' }, 2000);
+     * // When the first tween completes...
+     * tween.then(function() {
      *     // ...tween color back to blue.
-     *     item.tweenTo({fillColor: 'blue'}, 2000);
+     *     item.tweenTo({ fillColor: 'blue' }, 2000);
      * });
      */
     then: function(then) {
@@ -175,12 +169,12 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      *
      * @example {@paperscript}
      * // Manually start tweening.
-     * var item = new Path.Circle({
+     * var circle = new Path.Circle({
      *     center: view.center,
      *     radius: 50,
      *     fillColor: 'blue'
      * });
-     * var tween = item.tweenTo(
+     * var tween = circle.tweenTo(
      *     { fillColor: 'red' },
      *     { duration: 2000, start: false }
      * );
@@ -198,13 +192,13 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      *
      * @example {@paperscript}
      * // Stop a tween before it completes.
-     * var item = new Path.Circle({
+     * var circle = new Path.Circle({
      *     center: view.center,
      *     radius: 50,
      *     fillColor: 'blue'
      * });
      * // Start tweening from blue to red for 2 seconds.
-     * var tween = item.tweenTo({ fillColor: 'red' }, 2000);
+     * var tween = circle.tweenTo({ fillColor: 'red' }, 2000);
      * // After 1 second...
      * setTimeout(function(){
      *     // ...stop tweening.
@@ -216,6 +210,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         return this;
     },
 
+    // DOCS: Document Tween#update(progress)
     update: function(progress) {
         if (this.running) {
             if (progress > 1) {
@@ -240,11 +235,12 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
                     value = (from && to && from.__add && to.__add)
                         ? to.__subtract(from).__multiply(factor).__add(from)
                         : ((to - from) * factor) + from;
-                this._setItemProperty(this._parsedKeys[key], value);
+                this._setProperty(this._parsedKeys[key], value);
             }
 
             if (!this.running && this._then) {
-                this._then(this.item);
+                // TODO Look into what should be returned.
+                this._then(this.object);
             }
             if (this.responds('update')) {
                 this.emit('update', new Base({
@@ -269,47 +265,67 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      *
      * @example {@paperscript}
      * // Display tween progression values:
-     * var item = new Path.Circle({
+     * var circle = new Path.Circle({
      *     center: view.center,
-     *     radius: 50,
+     *     radius: 40,
      *     fillColor: 'blue'
      * });
-     * var tween = item.tweenTo(
+     * var tween = circle.tweenTo(
      *     { fillColor: 'red' },
-     *     { duration: 2000, easing: 'easeInCubic' }
+     *     {
+     *         duration: 2000,
+     *         easing: 'easeInCubic'
+     *     }
      * );
      * var progressText = new PointText(view.center + [60, -10]);
      * var factorText = new PointText(view.center + [60, 10]);
+     *
+     * // Install event using onUpdate() property:
      * tween.onUpdate = function(event) {
      *     progressText.content = 'progress: ' + event.progress.toFixed(2);
-     *     factorText.content = 'factor: ' + event.factor.toFixed(2);
      * };
+     *
+     * // Install event using on('update') method:
+     * tween.on('update', function(event) {
+     *     factorText.content = 'factor: ' + event.factor.toFixed(2);
+     * });
      */
     _events: {
         onUpdate: {}
     },
 
+    _handleFrame: function(time) {
+        var startTime = this._startTime,
+            progress = startTime
+                ? (time - startTime) / this.duration
+                : 0;
+        if (!startTime) {
+            this._startTime = time;
+        }
+        this.update(progress);
+    },
+
     _getState: function(state) {
         var keys = this._keys,
             result = {};
         for (var i = 0, l = keys.length; i < l; i++) {
             var key = keys[i],
                 path = this._parsedKeys[key],
-                current = this._getItemProperty(path),
+                current = this._getProperty(path),
                 value;
             if (state) {
                 var resolved = this._resolveValue(current, state[key]);
                 // Temporarily set the resolved value, so we can retrieve the
                 // coerced value from paper's internal magic.
-                this._setItemProperty(path, resolved);
-                value = this._getItemProperty(path);
+                this._setProperty(path, resolved);
+                value = this._getProperty(path);
                 // Clone the value if possible to prevent future changes.
-                value = value.clone ? value.clone() : value;
-                this._setItemProperty(path, current);
+                value = value && value.clone ? value.clone() : value;
+                this._setProperty(path, current);
             } else {
                 // We want to get the current state at the time of the call, so
                 // we have to clone if possible to prevent future changes.
-                value = current.clone ? current.clone() : current;
+                value = current && current.clone ? current.clone() : current;
             }
             result[key] = value;
         }
@@ -359,16 +375,16 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
         return parsed;
     },
 
-    _getItemProperty: function(path, offset) {
-        var obj = this.item;
+    _getProperty: function(path, offset) {
+        var obj = this.object;
         for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
             obj = obj[path[i]];
         }
         return obj;
     },
 
-    _setItemProperty: function(path, value) {
-        var dest = this._getItemProperty(path, 1);
+    _setProperty: function(path, value) {
+        var dest = this._getProperty(path, 1);
         if (dest) {
             dest[path[path.length - 1]] = value;
         }
diff --git a/src/item/Item.js b/src/item/Item.js
index 65e24f70..f499367c 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4695,7 +4695,22 @@ new function() { // Injection scope for hit-test functions shared with project
      *     radius: view.bounds.height * 0.4,
      *     center: view.center
      * });
-     * path.tween({ fillColor: 'blue' }, { fillColor: 'red' }, 3000);
+     * path.tween(
+     *     { fillColor: 'blue' },
+     *     { fillColor: 'red' },
+     *     3000
+     * );
+     * @example {@paperscript height=100}
+     * // Tween rotation:
+     * var path = new Shape.Rectangle({
+     *     fillColor: 'red',
+     *     point: view.center,
+     *     size: [50, 50]
+     * });
+     * path.tween({
+     *     easing: 'easeInOutCubic',
+     *     rotation: 180
+     * }, 2000);
      */
     /**
      * Tween item to a state.
@@ -4771,7 +4786,7 @@ new function() { // Injection scope for hit-test functions shared with project
             ),
             tween = new Tween(this, from, to, duration, easing, start);
         function onFrame(event) {
-            tween.handleFrame(event.time * 1000);
+            tween._handleFrame(event.time * 1000);
             if (!tween.running) {
                 this.off('frame', onFrame);
             }
@@ -4787,14 +4802,14 @@ new function() { // Injection scope for hit-test functions shared with project
      * Tween item to a state.
      *
      * @function
-     * @param {Object} state the state at the end of the tweening
+     * @param {Object} to the state at the end of the tweening
      * @param {Object|Number} options the options or the duration
      * @return {Tween}
      *
      * @see Item#tween(to, options)
      */
-    tweenTo: function(state, options) {
-        return this.tween(null, state, options);
+    tweenTo: function(to, options) {
+        return this.tween(null, to, options);
     },
 
     /**
@@ -4802,7 +4817,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * Tween item from a state to its state before the tweening.
      *
      * @function
-     * @param {Object} state the state at the start of the tweening
+     * @param {Object} from the state at the start of the tweening
      * @param {Object|Number} options the options or the duration
      * @return {Tween}
      *
@@ -4817,7 +4832,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * });
      * path.tweenFrom({ fillColor: 'red' }, { duration: 1000 });
      */
-    tweenFrom: function(state, options) {
-        return this.tween(state, null, options);
+    tweenFrom: function(from, options) {
+        return this.tween(from, null, options);
     }
 });
diff --git a/src/paper.js b/src/paper.js
index 1f5c153f..96c37775 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -65,7 +65,6 @@ var paper = function(self, undefined) {
 /*#*/ include('item/SymbolItem.js');
 /*#*/ include('item/SymbolDefinition.js');
 /*#*/ include('item/HitResult.js');
-/*#*/ include('item/Tween.js');
 
 /*#*/ include('path/Segment.js');
 /*#*/ include('path/SegmentPoint.js');
@@ -103,6 +102,8 @@ var paper = function(self, undefined) {
 /*#*/ include('tool/ToolEvent.js');
 /*#*/ include('tool/Tool.js');
 
+/*#*/ include('anim/Tween.js');
+
 /*#*/ include('net/Http.js');
 
 /*#*/ include('canvas/CanvasProvider.js');

From 4a5f558057542b185192ce2cb55d79c43e0e696b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 3 Dec 2018 13:59:51 +0100
Subject: [PATCH 036/181] Some minor tween example changes

---
 src/anim/Tween.js |  6 +++---
 src/item/Item.js  | 12 ++++++++----
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index d9655723..d3da643e 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -148,7 +148,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      * @return {Tween}
      *
      * @example {@paperscript} // Tweens chaining: var circle = new
-     * Path.Circle({center: view.center, radius: 50, fillColor: 'blue'
+     * Path.Circle({center: view.center, radius: 40, fillColor: 'blue'
      * });
      * // Tween color from blue to red.
      * var tween = item.tweenTo({ fillColor: 'red' }, 2000);
@@ -171,7 +171,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      * // Manually start tweening.
      * var circle = new Path.Circle({
      *     center: view.center,
-     *     radius: 50,
+     *     radius: 40,
      *     fillColor: 'blue'
      * });
      * var tween = circle.tweenTo(
@@ -194,7 +194,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      * // Stop a tween before it completes.
      * var circle = new Path.Circle({
      *     center: view.center,
-     *     radius: 50,
+     *     radius: 40,
      *     fillColor: 'blue'
      * });
      * // Start tweening from blue to red for 2 seconds.
diff --git a/src/item/Item.js b/src/item/Item.js
index f499367c..1c99c214 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4704,13 +4704,17 @@ new function() { // Injection scope for hit-test functions shared with project
      * // Tween rotation:
      * var path = new Shape.Rectangle({
      *     fillColor: 'red',
-     *     point: view.center,
-     *     size: [50, 50]
+     *     center: [50, view.center.y],
+     *     size: [60, 60]
      * });
      * path.tween({
+     *     rotation: 180,
+     *     'position.x': view.bounds.width - 50,
+     *     'fillColor.hue': '+= 90'
+     * }, {
      *     easing: 'easeInOutCubic',
-     *     rotation: 180
-     * }, 2000);
+     *     duration: 2000
+     * });
      */
     /**
      * Tween item to a state.

From 8ef5773ea173cd3739ccf4f68833afc2fc57b472 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 3 Dec 2018 14:19:11 +0100
Subject: [PATCH 037/181] Update CHANGELOG for upcoming v0.12.0

---
 CHANGELOG.md | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c344537..c32cead7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,28 @@
 # Change Log
 
-## Prebuilt version
+## `0.12.0`
+
+### News
+
+Another release, another new member on the team: Please welcome [@arnoson](https://github.com/arnoson), who has
+worked hard on the all new animation support, exposed through the `Tween` class
+and its various methods on the `Item` class, see below for details:
+
+### Added
+
+- Add new `Tween` class and related methods on `Item`, to animate and
+  interpolate their various properties, including colors, sub-properties, etc.:
+  `Item#tween(from, to, options)`, `Item#tween(to, options)`,
+  `Item#tween(options)`, `Item#tweenFrom(from, options)`,
+  `Item#tweenTo(to, options)`
 
 ### Fixed
 
-- Fix empty image drawing (#1320).
-
-### Added
+- Only draw Raster if image is not empty (#1320).
+- Emit mousedrag events on correct items when covered by other items (#1465).
+- Fix drawing issues of bounds and position with `Group#selectedColor` (#1571).
+- Fix `Item.once()` to actually only emit event once.
+- Various documentation fixes and improvements (#1399).
 
 ## `0.11.8`
 

From a66391678e6dfc03875daa337117ccecb8bd9327 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 3 Dec 2018 14:26:23 +0100
Subject: [PATCH 038/181] Release version 0.12.0

---
 dist/paper-core.js          | 15251 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 16995 +++++++++++++++++++++++++++++++++-
 gulp/tasks/publish.js       |     6 +-
 package.json                |     7 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 7 files changed, 32252 insertions(+), 13 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..83ebedc3
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15250 @@
+/*!
+ * Paper.js v0.12.0 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Mon Dec 3 14:19:11 2018 +0100
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2016 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg))
+							arg.insert = false;
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = n === 'trident' ? 'msie' : n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.0",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty()) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function() {
+		var children = this._children;
+		return !children || !children.length;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish)
+			ctx.clip();
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(
+				matrix && matrix.appended(clipItem._matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+
+	initialize: function Raster(object, position) {
+		if (!this._initialize(object,
+				position !== undefined && Point.read(arguments, 1))) {
+			var image = typeof object === 'string'
+					? document.getElementById(object) : object;
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(object);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(modify) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (modify) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		var half = size / 2,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (!(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			var epsilon = 1e-7,
+				ext = abs(extent),
+				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+				inc = extent / count,
+				half = inc * Math.PI / 360,
+				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+				segments = [];
+			for (var i = 0; i <= count; i++) {
+				var pt = to,
+					out = null;
+				if (i < count) {
+					out = vector.rotate(90).multiply(z);
+					if (matrix) {
+						pt = matrix._transformPoint(vector);
+						out = matrix._transformPoint(vector.add(out))
+								.subtract(pt);
+					} else {
+						pt = center.add(vector);
+					}
+				}
+				if (!i) {
+					current.setHandleOut(out);
+				} else {
+					var _in = vector.rotate(-90).multiply(z);
+					if (matrix) {
+						_in = matrix._transformPoint(vector.add(_in))
+								.subtract(pt);
+					}
+					segments.push(new Segment(pt, _in, out));
+				}
+				vector = vector.rotate(inc);
+			}
+			this._add(segments);
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix);
+		if (normal1.getDirectedAngle(normal2) < 0) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner)
+				this._owner._changed(129);
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		var color = Color.read(arguments, 0, { clone: true });
+		if (color)
+			color._owner = this;
+		this._color = color;
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old && old._owner !== undefined) {
+							old._owner = undefined;
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							if (value._owner)
+								value = value.clone();
+							value._owner = owner;
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone)
+						value = value.clone();
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+						if (value && isColor)
+							value._owner = owner;
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			matrix = matrix._shiftless();
+			var point = matrix._inverseTransform(trans);
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+			trans = null;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.y)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent) {
+		var value = SvgElement.get(node, name),
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
+			destination = origin.add(
+					getValue(node, 'r', false, false, scaleToBounds), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		}
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..84ba1912
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,16994 @@
+/*!
+ * Paper.js v0.12.0 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Mon Dec 3 14:19:11 2018 +0100
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2016 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg))
+							arg.insert = false;
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = n === 'trident' ? 'msie' : n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.0",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty()) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function() {
+		var children = this._children;
+		return !children || !children.length;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish)
+			ctx.clip();
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(
+				matrix && matrix.appended(clipItem._matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+
+	initialize: function Raster(object, position) {
+		if (!this._initialize(object,
+				position !== undefined && Point.read(arguments, 1))) {
+			var image = typeof object === 'string'
+					? document.getElementById(object) : object;
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(object);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(modify) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (modify) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		var half = size / 2,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (!(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			var epsilon = 1e-7,
+				ext = abs(extent),
+				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+				inc = extent / count,
+				half = inc * Math.PI / 360,
+				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+				segments = [];
+			for (var i = 0; i <= count; i++) {
+				var pt = to,
+					out = null;
+				if (i < count) {
+					out = vector.rotate(90).multiply(z);
+					if (matrix) {
+						pt = matrix._transformPoint(vector);
+						out = matrix._transformPoint(vector.add(out))
+								.subtract(pt);
+					} else {
+						pt = center.add(vector);
+					}
+				}
+				if (!i) {
+					current.setHandleOut(out);
+				} else {
+					var _in = vector.rotate(-90).multiply(z);
+					if (matrix) {
+						_in = matrix._transformPoint(vector.add(_in))
+								.subtract(pt);
+					}
+					segments.push(new Segment(pt, _in, out));
+				}
+				vector = vector.rotate(inc);
+			}
+			this._add(segments);
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix);
+		if (normal1.getDirectedAngle(normal2) < 0) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner)
+				this._owner._changed(129);
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		var color = Color.read(arguments, 0, { clone: true });
+		if (color)
+			color._owner = this;
+		this._color = color;
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old && old._owner !== undefined) {
+							old._owner = undefined;
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							if (value._owner)
+								value = value.clone();
+							value._owner = owner;
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone)
+						value = value.clone();
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+						if (value && isColor)
+							value._owner = owner;
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			matrix = matrix._shiftless();
+			var point = matrix._inverseTransform(trans);
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+			trans = null;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.y)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent) {
+		var value = SvgElement.get(node, name),
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
+			destination = origin.add(
+					getValue(node, 'r', false, false, scaleToBounds), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		}
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (!node.prefix
+								&& (parentType === 'AssignmentExpression'
+									|| parentType === 'VariableDeclarator')) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, view: view, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index f5ea1f92..3f685ff2 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -39,9 +39,9 @@ gulp.task('publish', function() {
     // publish:website comes before publish:release, so paperjs.zip file is gone
     // before npm publish:
     return run(
-        'publish:json',
-        'publish:dist',
-        'publish:packages',
+        //'publish:json',
+        // 'publish:dist',
+        // 'publish:packages',
         'publish:commit',
         'publish:website',
         'publish:release',
diff --git a/package.json b/package.json
index 4b7f05ae..95756b2b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
@@ -9,10 +9,7 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": [
-    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
-    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
-  ],
+  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
   "main": "dist/paper-full.js",
   "scripts": {
     "precommit": "gulp jshint --branch develop",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index f601084f..c3f05571 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit f601084fc319734d0bf47da700d6b6bff95260ba
+Subproject commit c3f055710eb887af55ea7039fbba50c9592fa4c4
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index a07b7d14..c4b63823 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit a07b7d149f02e980dfd837cd595f5000a9d5e052
+Subproject commit c4b6382389f13c065c4dc9be430b3bec2326dc23
diff --git a/src/options.js b/src/options.js
index 373d78eb..3285b843 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.11.8';
+var version = '0.12.0';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From 0cced9788cd6c3e4d15e4c0f6ad2f209a9a4b5fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 3 Dec 2018 14:29:13 +0100
Subject: [PATCH 039/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js    | 15251 +----------------------------------
 dist/paper-full.js    | 16995 +---------------------------------------
 gulp/tasks/publish.js |     6 +-
 3 files changed, 5 insertions(+), 32247 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 83ebedc3..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15250 +0,0 @@
-/*!
- * Paper.js v0.12.0 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Mon Dec 3 14:19:11 2018 +0100
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2016 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg))
-							arg.insert = false;
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = n === 'trident' ? 'msie' : n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.0",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty()) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function() {
-		var children = this._children;
-		return !children || !children.length;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish)
-			ctx.clip();
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(
-				matrix && matrix.appended(clipItem._matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-
-	initialize: function Raster(object, position) {
-		if (!this._initialize(object,
-				position !== undefined && Point.read(arguments, 1))) {
-			var image = typeof object === 'string'
-					? document.getElementById(object) : object;
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(object);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(modify) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (modify) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		var half = size / 2,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (!(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			var epsilon = 1e-7,
-				ext = abs(extent),
-				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-				inc = extent / count,
-				half = inc * Math.PI / 360,
-				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-				segments = [];
-			for (var i = 0; i <= count; i++) {
-				var pt = to,
-					out = null;
-				if (i < count) {
-					out = vector.rotate(90).multiply(z);
-					if (matrix) {
-						pt = matrix._transformPoint(vector);
-						out = matrix._transformPoint(vector.add(out))
-								.subtract(pt);
-					} else {
-						pt = center.add(vector);
-					}
-				}
-				if (!i) {
-					current.setHandleOut(out);
-				} else {
-					var _in = vector.rotate(-90).multiply(z);
-					if (matrix) {
-						_in = matrix._transformPoint(vector.add(_in))
-								.subtract(pt);
-					}
-					segments.push(new Segment(pt, _in, out));
-				}
-				vector = vector.rotate(inc);
-			}
-			this._add(segments);
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix);
-		if (normal1.getDirectedAngle(normal2) < 0) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner)
-				this._owner._changed(129);
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		var color = Color.read(arguments, 0, { clone: true });
-		if (color)
-			color._owner = this;
-		this._color = color;
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old && old._owner !== undefined) {
-							old._owner = undefined;
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							if (value._owner)
-								value = value.clone();
-							value._owner = owner;
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone)
-						value = value.clone();
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-						if (value && isColor)
-							value._owner = owner;
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			matrix = matrix._shiftless();
-			var point = matrix._inverseTransform(trans);
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-			trans = null;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.y)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent) {
-		var value = SvgElement.get(node, name),
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
-			destination = origin.add(
-					getValue(node, 'r', false, false, scaleToBounds), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		}
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index 84ba1912..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,16994 +0,0 @@
-/*!
- * Paper.js v0.12.0 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Mon Dec 3 14:19:11 2018 +0100
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2016 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg))
-							arg.insert = false;
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = n === 'trident' ? 'msie' : n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.0",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty()) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function() {
-		var children = this._children;
-		return !children || !children.length;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish)
-			ctx.clip();
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(
-				matrix && matrix.appended(clipItem._matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-
-	initialize: function Raster(object, position) {
-		if (!this._initialize(object,
-				position !== undefined && Point.read(arguments, 1))) {
-			var image = typeof object === 'string'
-					? document.getElementById(object) : object;
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(object);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(modify) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (modify) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		var half = size / 2,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (!(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			var epsilon = 1e-7,
-				ext = abs(extent),
-				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-				inc = extent / count,
-				half = inc * Math.PI / 360,
-				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-				segments = [];
-			for (var i = 0; i <= count; i++) {
-				var pt = to,
-					out = null;
-				if (i < count) {
-					out = vector.rotate(90).multiply(z);
-					if (matrix) {
-						pt = matrix._transformPoint(vector);
-						out = matrix._transformPoint(vector.add(out))
-								.subtract(pt);
-					} else {
-						pt = center.add(vector);
-					}
-				}
-				if (!i) {
-					current.setHandleOut(out);
-				} else {
-					var _in = vector.rotate(-90).multiply(z);
-					if (matrix) {
-						_in = matrix._transformPoint(vector.add(_in))
-								.subtract(pt);
-					}
-					segments.push(new Segment(pt, _in, out));
-				}
-				vector = vector.rotate(inc);
-			}
-			this._add(segments);
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix);
-		if (normal1.getDirectedAngle(normal2) < 0) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner)
-				this._owner._changed(129);
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		var color = Color.read(arguments, 0, { clone: true });
-		if (color)
-			color._owner = this;
-		this._color = color;
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old && old._owner !== undefined) {
-							old._owner = undefined;
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							if (value._owner)
-								value = value.clone();
-							value._owner = owner;
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone)
-						value = value.clone();
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-						if (value && isColor)
-							value._owner = owner;
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			matrix = matrix._shiftless();
-			var point = matrix._inverseTransform(trans);
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-			trans = null;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.y)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent) {
-		var value = SvgElement.get(node, name),
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
-			destination = origin.add(
-					getValue(node, 'r', false, false, scaleToBounds), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		}
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (!node.prefix
-								&& (parentType === 'AssignmentExpression'
-									|| parentType === 'VariableDeclarator')) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, view: view, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 3f685ff2..f5ea1f92 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -39,9 +39,9 @@ gulp.task('publish', function() {
     // publish:website comes before publish:release, so paperjs.zip file is gone
     // before npm publish:
     return run(
-        //'publish:json',
-        // 'publish:dist',
-        // 'publish:packages',
+        'publish:json',
+        'publish:dist',
+        'publish:packages',
         'publish:commit',
         'publish:website',
         'publish:release',

From bbd65324bc7e689627b8f00b383fbfe4a9ec33f1 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 21 Nov 2018 12:18:21 +0100
Subject: [PATCH 040/181] Add typescript definition generation

This add a gulp task (`gulp docs:typescript`) to automatically generate
a typescript definition for the library. This should solve the problem
of having an out of sync type definition when we change the API.

This task takes advantage of existing JSDoc parsing to generate a
temporary file which is later formatted through a mustache template to
generate the final definition. This definition is then tested by
compiling a typescript file that use it.
The generated definition is added to the `gulp zip` task in order to be
published along with the bundled library.

So 2 new dev-dependencies are added with this change: `mustache` and
`typescript` packages. Using node and mustache to generate the
definition instead of relying on existing templating system is
motivated by a better development experience, with easier debugging
possibilities... through the usage of more modern tools.

As a side note, support of "rest parameters" (when a parameter can be
present multiple times) is added to existing JSDoc parser in order to
support this pattern on typescript side (E.g. for `Color#set()` method
which accept any sequence of parameters that is supported by `Color`
constructors).
---
 gulp/tasks/dist.js                            |    1 +
 gulp/tasks/docs.js                            |   59 +-
 .../typescript-definition-generator.js        |  317 +++++
 .../typescript-definition-template.mustache   |   59 +
 gulp/typescript/typescript-definition-test.ts | 1155 +++++++++++++++++
 package.json                                  |    4 +-
 src/basic/Matrix.js                           |    1 +
 src/basic/Point.js                            |    1 +
 src/basic/Rectangle.js                        |    1 +
 src/basic/Size.js                             |    1 +
 src/style/Color.js                            |    1 +
 11 files changed, 1591 insertions(+), 9 deletions(-)
 create mode 100644 gulp/typescript/typescript-definition-generator.js
 create mode 100644 gulp/typescript/typescript-definition-template.mustache
 create mode 100644 gulp/typescript/typescript-definition-test.ts

diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index f80d2367..3d323b99 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -22,6 +22,7 @@ gulp.task('zip', ['clean:zip', 'dist'], function() {
             gulp.src([
                 'dist/paper-full*.js',
                 'dist/paper-core*.js',
+                'dist/index.d.ts',
                 'dist/node/**/*',
                 'LICENSE.txt',
                 'examples/**/*',
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index 96728ea4..9459f5d0 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -14,14 +14,15 @@ var gulp = require('gulp'),
     del = require('del'),
     rename = require('gulp-rename'),
     shell = require('gulp-shell'),
-    options = require('../utils/options.js');
+    options = require('../utils/options.js'),
+    run = require('run-sequence');
 
 var docOptions = {
     local: 'docs', // Generates the offline docs
     server: 'serverdocs' // Generates the website templates for the online docs
 };
 
-gulp.task('docs', ['docs:local', 'build:full'], function() {
+gulp.task('docs', ['docs:local', 'docs:typescript', 'build:full'], function() {
     return gulp.src('dist/paper-full.js')
         .pipe(rename({ basename: 'paper' }))
         .pipe(gulp.dest('dist/docs/assets/js/'));
@@ -32,15 +33,57 @@ Object.keys(docOptions).forEach(function(name) {
         var mode = docOptions[name];
         return gulp.src('src')
             .pipe(shell(
-                ['java -cp jsrun.jar:lib/* JsRun app/run.js',
-                ' -c=conf/', name, '.conf ',
-                ' -D="renderMode:', mode, '" ',
-                ' -D="version:', options.version, '"'].join(''),
+                [
+                    'java -cp jsrun.jar:lib/* JsRun app/run.js',
+                    ' -c=conf/', name, '.conf ',
+                    ' -D="renderMode:', mode, '" ',
+                    ' -D="version:', options.version, '"'
+                ].join(''),
                 { cwd: 'gulp/jsdoc' })
-            )
+            );
     });
 
     gulp.task('clean:docs:' + name, function() {
-        return del([ 'dist/' + docOptions[name] + '/**' ]);
+        return del(['dist/' + docOptions[name] + '/**']);
     });
 });
+
+// The goal of the typescript task is to automatically generate a type
+// definition for the library.
+gulp.task('docs:typescript', function() {
+    return run(
+        'docs:typescript:clean:before',
+        'docs:typescript:build',
+        'docs:typescript:clean:after'
+    );
+});
+// First clean eventually existing type definition...
+gulp.task('docs:typescript:clean:before', function() {
+    return del('dist/index.d.ts');
+});
+// ...then build the definition...
+gulp.task('docs:typescript:build', function() {
+    // First parse JSDoc comments and store parsed data in a temporary file...
+    return gulp.src('src')
+        .pipe(shell(
+            [
+                'java -cp jsrun.jar:lib/* JsRun app/run.js',
+                ' -c=conf/typescript.conf ',
+                ' -D="file:../../gulp/typescript/typescript-definition-data.json"',
+                ' -D="version:', options.version, '"',
+                ' -D="date:', options.date, '"'
+            ].join(''),
+            { cwd: 'gulp/jsdoc' })
+        )
+        // ...then generate definition from parsed data...
+        .pipe(shell('node gulp/typescript/typescript-definition-generator.js'))
+        // ...finally test the definition by compiling a typescript file.
+        .pipe(shell('node node_modules/typescript/bin/tsc gulp/typescript/typescript-definition-test.ts'));
+});
+// ...finally remove all unneeded temporary files that were used for building.
+gulp.task('docs:typescript:clean:after', function() {
+    return del([
+        'gulp/typescript/typescript-definition-data.json',
+        'gulp/typescript/typescript-definition-test.js'
+    ]);
+});
diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
new file mode 100644
index 00000000..e4dfda30
--- /dev/null
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -0,0 +1,317 @@
+/**
+ * This script generates a type definition by taking JSDoc roughly parsed data,
+ * formatting it and passing it to a mustache template.
+ */
+
+const fs = require('fs');
+const mustache = require('mustache');
+
+// Retrieve JSDoc data.
+const data = JSON.parse(fs.readFileSync(__dirname + '/typescript-definition-data.json', 'utf8'));
+const classes = data.classes;
+let globals = data.global.properties;
+
+// Format classes.
+classes.forEach(cls => {
+    // Format class.
+    // Store name as `className` and not simply `name`, to avoid name conflict
+    // in static constructors block.
+    cls.className = cls._name;
+    // Store closest parent if there is one.
+    cls.extends = cls.inheritsFrom && cls.inheritsFrom.length > 0
+        ? cls.inheritsFrom[0]
+        : null;
+    // Store comment using class tag as description.
+    cls.comment = formatComment(cls.comment, 'class');
+
+    // Build a filter for deprecated or inherited methods or properties.
+    const filter = _ => !_.deprecated && _.memberOf == cls.alias && !_.isNamespace;
+
+    // Format properties.
+    cls.properties = cls.properties
+        .filter(filter)
+        .map(_ => ({
+            name: _._name,
+            type: formatType(_.type),
+            static: formatStatic(_.isStatic),
+            readOnly: formatReadOnly(_.readOnly),
+            comment: formatComment(_.comment)
+        }));
+
+    // Format methods.
+    const methods = cls.methods
+        .filter(filter)
+        .map(_ => {
+            const name = formatMethodName(_._name);
+            const isStaticConstructor = _.isStatic && _.isConstructor;
+            return {
+                name: name,
+                // Constructors don't need return type.
+                type: !_.isConstructor
+                    ? formatType(getMethodReturnType(_), true)
+                    : '',
+                static: formatStatic(_.isStatic),
+                // This flag is only used below to filter methods.
+                isStaticConstructor: isStaticConstructor,
+                comment: formatComment(_.comment, 'desc', _.isConstructor),
+                params: _._params
+                    ? _._params
+                    // Filter internal parameters (starting with underscore).
+                        .filter(_ => !/^_/.test(_.name))
+                        .map(_ => formatParameter(_, isStaticConstructor && cls))
+                        .join(', ')
+                    : ''
+            };
+        })
+        .sort(sortMethods);
+
+    // Divide methods in 2 parts: static constructors and other. Because static
+    // constructors need a special syntax in type definition.
+    cls.methods = [];
+    cls.staticConstructors = [];
+    methods.forEach(method => {
+        if (method.isStaticConstructor) {
+            // Group static constructors by method name.
+            let staticConstructors = cls.staticConstructors.find(_ => _.name === method.name);
+            if (!staticConstructors) {
+                staticConstructors = {
+                    name: method.name,
+                    constructors: []
+                };
+                cls.staticConstructors.push(staticConstructors);
+            }
+            staticConstructors.constructors.push(method);
+        } else {
+            cls.methods.push(method);
+        }
+    });
+    // Store a conveniance flag to check whether class has static constructors.
+    cls.hasStaticConstructors = cls.staticConstructors.length > 0;
+});
+
+// Format global vriables.
+globals = globals
+// Filter global variables that make no sense in type definition.
+    .filter(_ => !/^on/.test(_._name) && _._name !== 'paper')
+    .map(_ => ({
+        name: _._name,
+        type: formatType(_.type),
+        comment: formatComment(_.comment)
+    }));
+
+// Format data trough a mustache template.
+// Prepare data for the template.
+const context = {
+    classes: classes,
+    globals: globals,
+    version: data.version,
+    date: data.date,
+    // {{#doc}} blocks are used in template to automatically generate a JSDoc
+    // comment with a custom indent.
+    doc: () => formatJSDoc
+};
+// Retrieve template content.
+const template = fs.readFileSync(__dirname + '/typescript-definition-template.mustache', 'utf8');
+// Render template.
+const output = mustache.render(template, context);
+// Write output in a file.
+fs.writeFileSync(__dirname + '/../../dist/index.d.ts', output, 'utf8');
+
+
+//
+// METHODS
+//
+
+function formatReadOnly(isReadOnly) {
+    return isReadOnly ? 'readonly ' : null;
+}
+
+function formatStatic(isStatic) {
+    return isStatic ? 'static ' : null;
+}
+
+function formatType(type, isMethodReturnType, staticConstructorClass) {
+    return ': ' + parseType(type, isMethodReturnType, staticConstructorClass);
+}
+
+function parseType(type, isMethodReturnType, staticConstructorClass) {
+    // Always return a type even if input type is empty. In that case, return
+    // `void` for method return type and `any` for the rest.
+    if (!type) {
+        return isMethodReturnType ? 'void' : 'any';
+    }
+    if (type === '*') {
+        return 'any';
+    }
+    // Prefer `any[]` over `Array<any>` to be more consistent with other types.
+    if (type === 'Array') {
+        return 'any[]';
+    }
+    // Handle multiple types possibility by splitting on `|` then re-joining
+    // back parsed types.
+    return type.split('|').map(type => {
+        // Handle rest parameter pattern: `...Type` => `Type[]`
+        const matches = type.match(/^\.\.\.(.+)$/);
+        if (matches) {
+            return parseType(matches[1]) + '[]';
+        }
+        // Get type without array suffix `[]` for easier matching.
+        const singleType = type.replace(/(\[\])+$/, '');
+        // Handle eventual type conflict in static constructors block. For
+        // example, in `Path.Rectangle(rectangle: Rectangle)` method,
+        // `rectangle` parameter type must be mapped to `paper.Rectangle` as it
+        // is declared inside a `Path` namespace and would otherwise be wrongly
+        // assumed as being the type of `Path.Rectangle` class.
+        if (staticConstructorClass && staticConstructorClass.methods.find(_ => _.isStatic && _.isConstructor && formatMethodName(_._name) === singleType)
+        ) {
+            return 'paper.' + type;
+        }
+        // Convert primitive types to their lowercase equivalent to suit
+        // typescript best practices.
+        return ['Number', 'String', 'Boolean', 'Object'].indexOf(singleType) >= 0
+            ? type.toLowerCase()
+            : type;
+    }).join(' | ');
+}
+
+function formatMethodName(methodName) {
+    // Overloaded methods were parsed as `method^0`, `method^1`... here, we
+    // turn them back to `method` as typescript allow overloading.
+    methodName = methodName.replace(/\^[0-9]+$/, '');
+    // Real contructors are called `initialize` in the library.
+    methodName = methodName.replace(/^initialize$/, 'constructor');
+    return methodName;
+}
+
+function formatParameter(_, staticConstructorClass) {
+    let content = '';
+    // Handle rest parameter pattern `...Type`. Parameter name needs to be
+    // prefixed with `...` as in ES6. E.g. `...parameter: type[]`.
+    if (_.type.match(/^\.\.\.(.+)$/)) {
+        content += '...';
+    }
+    content += formatParameterName(_.name);
+    // Optional parameters are formatted as: `parameter?: type`.
+    if (_.isOptional) {
+        content += '?';
+    }
+    content += formatType(_.type, false, staticConstructorClass);
+    return content;
+}
+
+function formatParameterName(parameterName) {
+    // Avoid usage of reserved keyword as parameter name.
+    // E.g. `function` => `callback`.
+    if (parameterName === 'function') {
+        return 'callback';
+    }
+    return parameterName;
+}
+
+function formatComment(comment, descriptionTagName = 'desc', skipReturn = false) {
+    const tags = comment.tags;
+    let content = '';
+
+    // Retrieve description tag.
+    const descriptionTag = tags.find(_ => _.title === descriptionTagName);
+    if (descriptionTag) {
+        // Don't display group titles.
+        content += descriptionTag.desc.replace(/\{@grouptitle .+?\}/g, '').trim();
+    }
+
+    // Preserve some of the JSDoc tags that can be usefull even in type
+    // definition. Format their values to make sure that only informations
+    // that make sense are kept. E.g. method parameters types are already
+    // provided in the signature...
+    content += formatCommentTags(tags, 'see');
+    content += formatCommentTags(tags, 'option');
+    content += formatCommentTags(tags, 'param', _ => _.name + ' - ' + _.desc);
+
+    if (!skipReturn) {
+        content += formatCommentTags(tags, 'return', _ => _.desc.trim().replace(/^\{|\}$/g, '').replace(/@([a-zA-Z]+)/, '$1'));
+    }
+
+    // Make sure links are followable (e.g. by IDEs) by removing parameters.
+    // {@link Class#method(param)} => {@link Class#method}
+    content = content.replace(/(\{@link [^\}]+?)\(.*?\)(\})/g, '$1$2');
+
+    content = content.trim();
+    return content;
+}
+
+function formatCommentTags(tags, tagName, formatter) {
+    let content = '';
+    // Default formatter simply outputs description.
+    formatter = formatter || (_ => _.desc);
+    // Only keep tags that have a description.
+    tags = tags.filter(_ => _.desc && _.title === tagName);
+    if (tags.length > 0) {
+        content += '\n';
+        // Display tag as it was in original JSDoc, followed by formatted value.
+        tags.forEach(_ => content += '\n@' + tagName + ' ' + formatter(_));
+    }
+    return content;
+}
+
+/**
+ * This outputs a JSDoc comment indented at the given offset and including the
+ * parsed comment for current mustache block.
+ * @param {Number} offset the number of spaces to use for indentation
+ * @param {Function} render the mustache render method
+ * @return {string} the formatted JSDoc comment
+ */
+function formatJSDoc(offset, render) {
+    // First render current block comment. Use `{{&}}` syntax to make sure
+    // special characters are not escaped.
+    let content = render('{{&comment}}');
+    if (!content) {
+        return '';
+    }
+
+    // Build indentation.
+    offset = parseInt(offset);
+    if (offset > 0) {
+        offset++;
+    }
+    const indentation = new Array(offset).join(' ');
+
+    // Prefix each line with the indentation.
+    content = content.split('\n')
+        .map(_ => indentation + ' * ' + _)
+        .join('\n');
+
+    // Wrap content in JSDoc delimiters: `/**` and `*/`.
+    return '/** \n' + content + '\n' + indentation + ' */';
+}
+
+function getMethodReturnType(_) {
+    return _.returnType || _.returns.length > 0 && _.returns[0].type;
+}
+
+function sortMethods(methodA, methodB) {
+    // This places constructors before other methods as it is a best practice.
+    // This also place constructors with only one object parameter after other
+    // constructors to avoid type inference errors due to constructors
+    // overloading order. E.g. if `constructor(object: object)` is defined
+    // before `constructor(instance: Class)`, calling `constructor(instance)`
+    // will always be mapped to `contructor(object: object)`, since everything
+    // is an object in JavaScript. This is problematic because most of Paper.js
+    // classes have a constructor accepting an object.
+    const aIsContructor = methodA.name === 'constructor';
+    const bIsContructor = methodB.name === 'constructor';
+    if (aIsContructor && bIsContructor) {
+        if (methodA.params === 'object: object') {
+            return 1;
+        }
+        if (methodB.params === 'object: object') {
+            return -1;
+        }
+    }
+    else if (aIsContructor) {
+        return -1;
+    }
+    else if (bIsContructor) {
+        return 1;
+    }
+    return 0;
+}
diff --git a/gulp/typescript/typescript-definition-template.mustache b/gulp/typescript/typescript-definition-template.mustache
new file mode 100644
index 00000000..a7856e17
--- /dev/null
+++ b/gulp/typescript/typescript-definition-template.mustache
@@ -0,0 +1,59 @@
+/*!
+ * Paper.js v{{version}} - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: {{date}}
+ *
+ * This is an auto-generated type definition.
+ */
+
+declare module paper {
+    {{#globals}}
+    {{#doc}}4{{/doc}}
+    let {{name}}{{type}}
+
+    {{/globals}}
+
+    {{#classes}}
+
+    {{#doc}}4{{/doc}}
+    class {{className}} {{#extends}}extends {{extends}}{{/extends}} {
+        {{#properties}}
+        {{#doc}}8{{/doc}}
+        {{static}}{{readOnly}}{{name}}{{type}}
+
+        {{/properties}}
+
+        {{#methods}}
+        {{#doc}}8{{/doc}}
+        {{static}}{{name}}({{params}}){{type}}
+
+        {{/methods}}
+    }
+    {{#hasStaticConstructors}}
+    namespace {{className}} {
+        {{#staticConstructors}}
+
+        class {{name}} extends {{className}} {
+            {{#constructors}}
+            {{#doc}}12{{/doc}}
+            constructor({{params}})
+
+            {{/constructors}}
+        }
+        {{/staticConstructors}}
+    }
+    {{/hasStaticConstructors}}
+    {{/classes}}
+}
+
+declare module 'paper' {
+    export = paper
+}
diff --git a/gulp/typescript/typescript-definition-test.ts b/gulp/typescript/typescript-definition-test.ts
new file mode 100644
index 00000000..22431122
--- /dev/null
+++ b/gulp/typescript/typescript-definition-test.ts
@@ -0,0 +1,1155 @@
+/// <reference path="../../dist/index.d.ts" />
+
+/**
+ * This file is used as a way to test auto-generated typescript definition
+ * validity. For now, this only check that calling methods as they are defined
+ * in online documentation does not throw error in typescript compilation.
+ *
+ * Todo: add more advanced type checking by using either:
+ * - typescript compiler check: `let result:type = methodCall()`
+ * - dedicated testing library like: https://github.com/Microsoft/dtslint
+ */
+
+import * as paper from 'paper';
+
+
+//
+// Global
+//
+
+paper.project;
+paper.projects;
+paper.view;
+paper.tool;
+paper.tools;
+
+
+//
+// Utility variables
+//
+
+let point            = {} as paper.Point;
+let size             = {} as paper.Size;
+let rectangle        = {} as paper.Rectangle;
+let matrix           = {} as paper.Matrix;
+let project          = {} as paper.Project;
+let item             = {} as paper.Item;
+let layer            = {} as paper.Layer;
+let group            = {} as paper.Group;
+let shape            = {} as paper.Shape;
+let raster           = {} as paper.Raster;
+let pathItem         = {} as paper.PathItem;
+let path             = {} as paper.Path;
+let compoundPath     = {} as paper.CompoundPath;
+let segment          = {} as paper.Segment;
+let curve            = {} as paper.Curve;
+let curveLocation    = {} as paper.CurveLocation;
+let symbolDefinition = {} as paper.SymbolDefinition;
+let symbolItem       = {} as paper.SymbolItem;
+let style            = {} as paper.Style;
+let color            = {} as paper.Color;
+let gradient         = {} as paper.Gradient;
+let gradientStop     = {} as paper.GradientStop;
+let textItem         = {} as paper.TextItem;
+let pointText        = {} as paper.PointText;
+let view             = {} as paper.View;
+let event            = {} as paper.Event;
+let mouseEvent       = {} as paper.MouseEvent;
+let tool             = {} as paper.Tool;
+let toolEvent        = {} as paper.ToolEvent;
+let keyEvent         = {} as paper.KeyEvent;
+let paperScope       = {} as paper.PaperScope;
+let callback         = {} as () => {};
+let hitResult        = {} as paper.HitResult;
+let object           = {} as object;
+
+
+//
+// Classes
+//
+
+//
+// Point
+//
+
+new paper.Point(0, 0);
+new paper.Point([ 0, 0 ]);
+new paper.Point({ x: 0, y: 0 });
+new paper.Point(size);
+new paper.Point(point);
+point.x;
+point.y;
+point.length;
+point.angle;
+point.angleInRadians;
+point.quadrant;
+point.selected;
+point.set(0, 0);
+point.set([ 0, 0 ]);
+point.set({ x: 0, y: 0 });
+point.set(size);
+point.set(point);
+point.equals(point);
+point.clone();
+point.toString();
+point.getAngle(point);
+point.getAngleInRadians(point);
+point.getDirectedAngle(point);
+point.getDistance(point, true);
+point.normalize();
+point.normalize(0);
+point.rotate(0, point);
+point.transform(matrix);
+point.isInside(rectangle);
+point.isClose(point, 0);
+point.isCollinear(point);
+point.isOrthogonal(point);
+point.isZero();
+point.isNaN();
+point.isInQuadrant(0);
+point.dot(point);
+point.cross(point);
+point.project(point);
+point.round();
+point.ceil();
+point.floor();
+point.abs();
+point.add(0);
+point.add(point);
+point.subtract(0);
+point.subtract(point);
+point.multiply(0);
+point.multiply(point);
+point.divide(0);
+point.divide(point);
+point.modulo(0);
+point.modulo(point);
+paper.Point.min(point, point);
+paper.Point.max(point, point);
+paper.Point.random();
+
+
+//
+// Size
+//
+
+
+new paper.Size(0, 0);
+new paper.Size([ 0, 0 ]);
+new paper.Size({ width: 0, height: 0 });
+new paper.Size(size);
+new paper.Size(point);
+size.width;
+size.height;
+size.set(0, 0);
+size.set([ 0, 0 ]);
+size.set({ x: 0, y: 0 });
+size.set(size);
+size.set(point);
+size.equals(size);
+size.clone();
+size.toString();
+size.isZero();
+size.isNaN();
+size.round();
+size.ceil();
+size.floor();
+size.abs();
+size.add(0);
+size.add(size);
+size.subtract(0);
+size.subtract(size);
+size.multiply(0);
+size.multiply(size);
+size.divide(0);
+size.divide(size);
+size.modulo(0);
+size.modulo(size);
+paper.Size.min(size, size);
+paper.Size.max(size, size);
+paper.Size.random();
+
+
+//
+// Rectangle
+//
+
+
+new paper.Rectangle(point, size);
+new paper.Rectangle({ point: point, size: size });
+new paper.Rectangle(0, 0, 0, 0);
+new paper.Rectangle(point, point);
+new paper.Rectangle(rectangle);
+rectangle.x;
+rectangle.y;
+rectangle.width;
+rectangle.height;
+rectangle.point;
+rectangle.size;
+rectangle.left;
+rectangle.top;
+rectangle.right;
+rectangle.bottom;
+rectangle.center;
+rectangle.topLeft;
+rectangle.topRight;
+rectangle.bottomLeft;
+rectangle.bottomRight;
+rectangle.leftCenter;
+rectangle.topCenter;
+rectangle.rightCenter;
+rectangle.bottomCenter;
+rectangle.area;
+rectangle.selected;
+rectangle.set(point, size);
+rectangle.set({ point: point, size: size });
+rectangle.set(0, 0, 0, 0);
+rectangle.set(point, point);
+rectangle.set(rectangle);
+rectangle.clone();
+rectangle.equals(rectangle);
+rectangle.toString();
+rectangle.isEmpty();
+rectangle.contains(point);
+rectangle.contains(rectangle);
+rectangle.intersects(rectangle);
+rectangle.intersects(rectangle, 0);
+rectangle.intersect(rectangle);
+rectangle.unite(rectangle);
+rectangle.include(point);
+rectangle.expand(0);
+rectangle.expand(0, 0);
+rectangle.scale(0);
+rectangle.scale(0, 0);
+
+
+//
+// Matrix
+//
+
+new paper.Matrix();
+new paper.Matrix(0, 0, 0, 0, 0, 0);
+new paper.Matrix([ 0, 0, 0, 0, 0, 0 ]);
+new paper.Matrix(matrix);
+matrix.a;
+matrix.b;
+matrix.c;
+matrix.d;
+matrix.tx;
+matrix.ty;
+matrix.values;
+matrix.translation;
+matrix.scaling;
+matrix.rotation;
+matrix.set(0, 0, 0, 0, 0, 0);
+matrix.set([ 0, 0, 0, 0, 0, 0 ]);
+matrix.set(matrix);
+matrix.clone();
+matrix.equals(matrix);
+matrix.toString();
+matrix.reset();
+matrix.apply();
+matrix.apply(true);
+matrix.translate(point);
+matrix.translate(0, 0);
+matrix.scale(0);
+matrix.scale(0, point);
+matrix.scale(0, 0);
+matrix.scale(0, 0, point);
+matrix.rotate(0, point);
+matrix.rotate(0, 0, 0);
+matrix.shear(point);
+matrix.shear(point, point);
+matrix.shear(0, 0);
+matrix.shear(0, 0, point);
+matrix.skew(point);
+matrix.skew(point, point);
+matrix.skew(0, 0);
+matrix.skew(0, 0, point);
+matrix.append(matrix);
+matrix.prepend(matrix);
+matrix.appended(matrix);
+matrix.prepended(matrix);
+matrix.invert();
+matrix.inverted();
+matrix.isIdentity();
+matrix.isInvertible();
+matrix.isSingular();
+matrix.transform(point);
+matrix.transform([ 0, 0 ], [ 0, 0 ], 0);
+matrix.inverseTransform(point);
+matrix.decompose();
+matrix.applyToContext({} as CanvasRenderingContext2D);
+
+
+//
+// Project
+//
+
+new paper.Project({} as HTMLCanvasElement);
+new paper.Project('');
+new paper.Project(size);
+project.view;
+project.currentStyle;
+project.index;
+project.layers;
+project.activeLayer;
+project.symbolDefinitions;
+project.selectedItems;
+project.activate();
+project.clear();
+project.isEmpty();
+project.remove();
+project.selectAll();
+project.deselectAll();
+project.addLayer(layer);
+project.insertLayer(0, layer);
+project.hitTest(point);
+project.hitTest(point, {});
+project.hitTestAll(point);
+project.hitTestAll(point, {});
+project.getItems({});
+project.getItems(callback);
+project.getItem({});
+project.getItem(callback);
+project.exportJSON();
+project.exportJSON({});
+project.importJSON('');
+project.exportSVG();
+project.exportSVG({});
+project.importSVG('');
+project.importSVG({} as SVGElement);
+project.importSVG('', {});
+project.importSVG('', callback);
+
+
+//
+// Item
+//
+
+item.id;
+item.className;
+item.name;
+item.style;
+item.locked;
+item.visible;
+item.blendMode;
+item.opacity;
+item.selected;
+item.clipMask;
+item.data;
+item.position;
+item.pivot;
+item.bounds;
+item.strokeBounds;
+item.handleBounds;
+item.rotation;
+item.scaling;
+item.matrix;
+item.globalMatrix;
+item.viewMatrix;
+item.applyMatrix;
+item.project;
+item.view;
+item.layer;
+item.parent;
+item.children;
+item.firstChild;
+item.lastChild;
+item.nextSibling;
+item.previousSibling;
+item.index;
+item.strokeColor;
+item.strokeWidth;
+item.strokeCap;
+item.strokeJoin;
+item.dashOffset;
+item.strokeScaling;
+item.dashArray;
+item.miterLimit;
+item.fillColor;
+item.fillRule;
+item.shadowColor;
+item.shadowBlur;
+item.shadowOffset;
+item.selectedColor;
+item.onFrame;
+item.onMouseDown;
+item.onMouseDrag;
+item.onMouseUp;
+item.onClick;
+item.onDoubleClick;
+item.onMouseMove;
+item.onMouseEnter;
+item.onMouseLeave;
+item.set({});
+item.clone();
+item.clone({});
+item.copyContent(item);
+item.copyAttributes(item, true);
+item.rasterize();
+item.rasterize(0);
+item.rasterize(0, true);
+item.contains(point);
+item.isInside(rectangle);
+item.intersects(item);
+item.hitTest(point);
+item.hitTest(point, {});
+item.hitTestAll(point);
+item.hitTestAll(point, {});
+item.matches({});
+item.matches(callback);
+item.matches(name, {});
+item.getItems({});
+item.getItems(callback);
+item.getItem({});
+item.getItem(callback);
+item.exportJSON();
+item.exportJSON({});
+item.importJSON('');
+item.exportSVG();
+item.exportSVG({});
+item.importSVG('');
+item.importSVG({} as SVGElement);
+item.importSVG('', {});
+item.importSVG('', callback);
+item.addChild(item);
+item.insertChild(0, item);
+item.addChildren([ item ]);
+item.insertChildren(0, [ item ]);
+item.insertAbove(item);
+item.insertBelow(item);
+item.sendToBack();
+item.bringToFront();
+item.addTo(group);
+item.copyTo(group);
+item.reduce({});
+item.remove();
+item.replaceWith(item);
+item.removeChildren();
+item.removeChildren(0);
+item.removeChildren(0, 0);
+item.reverseChildren();
+item.isEmpty();
+item.hasFill();
+item.hasStroke();
+item.hasShadow();
+item.hasChildren();
+item.isInserted();
+item.isAbove(item);
+item.isBelow(item);
+item.isParent(item);
+item.isChild(item);
+item.isDescendant(item);
+item.isAncestor(item);
+item.isSibling(item);
+item.isGroupedWith(item);
+item.translate(point);
+item.rotate(0);
+item.rotate(0, point);
+item.scale(0);
+item.scale(0, point);
+item.scale(0, 0);
+item.scale(0, 0, point);
+item.shear(point);
+item.shear(point, point);
+item.shear(0, 0);
+item.shear(0, 0, point);
+item.skew(point);
+item.skew(point, point);
+item.skew(0, 0);
+item.skew(0, 0, point);
+item.transform(matrix);
+item.globalToLocal(point);
+item.localToGlobal(point);
+item.parentToLocal(point);
+item.localToParent(point);
+item.fitBounds(rectangle);
+item.fitBounds(rectangle, true);
+item.on('', callback);
+item.on({});
+item.off('', callback);
+item.off({});
+item.emit('', event);
+item.responds('');
+item.removeOn({});
+item.removeOnMove();
+item.removeOnDown();
+item.removeOnDrag();
+item.removeOnUp();
+
+
+//
+// Layer
+//
+
+new paper.Layer([ item ]);
+new paper.Layer({});
+layer.activate();
+
+
+//
+// Group
+//
+
+new paper.Group([ item ]);
+new paper.Group({});
+group.clipped;
+
+
+//
+// Shape
+//
+
+new paper.Shape.Circle(point, 0);
+new paper.Shape.Circle({});
+new paper.Shape.Rectangle(rectangle);
+new paper.Shape.Rectangle(rectangle, size);
+new paper.Shape.Rectangle(point, size);
+new paper.Shape.Rectangle(point, point);
+new paper.Shape.Rectangle({});
+new paper.Shape.Ellipse(rectangle);
+new paper.Shape.Ellipse({});
+shape.type;
+shape.size;
+shape.radius;
+shape.toPath();
+shape.toPath(true);
+
+
+//
+// Raster
+//
+
+new paper.Raster();
+new paper.Raster({} as HTMLImageElement);
+new paper.Raster({} as HTMLCanvasElement);
+new paper.Raster('');
+new paper.Raster('', point);
+raster.size;
+raster.width;
+raster.height;
+raster.loaded;
+raster.resolution;
+raster.image;
+raster.canvas;
+raster.context;
+raster.source;
+raster.crossOrigin;
+raster.smoothing;
+raster.onLoad;
+raster.onError;
+raster.getSubCanvas(rectangle);
+raster.getSubRaster(rectangle);
+raster.toDataURL();
+raster.drawImage({} as HTMLImageElement, point);
+raster.getAverageColor(path);
+raster.getAverageColor(rectangle);
+raster.getAverageColor(point);
+raster.getPixel(0, 0);
+raster.getPixel(point);
+raster.setPixel(0, 0, color);
+raster.setPixel(point, color);
+raster.createImageData(size);
+raster.getImageData(rectangle);
+raster.setImageData({} as ImageData, point);
+
+
+//
+// HitResult
+//
+
+hitResult.type;
+hitResult.name;
+hitResult.item;
+hitResult.location;
+hitResult.color;
+hitResult.segment;
+hitResult.point;
+
+
+//
+// PathItem
+//
+
+pathItem.interiorPoint;
+pathItem.clockwise;
+pathItem.pathData;
+pathItem.unite(path);
+pathItem.unite(path, {});
+pathItem.intersect(path);
+pathItem.intersect(path, {});
+pathItem.subtract(path);
+pathItem.subtract(path, {});
+pathItem.exclude(path);
+pathItem.exclude(path, {});
+pathItem.divide(path);
+pathItem.divide(path, {});
+pathItem.reorient();
+pathItem.reorient(true);
+pathItem.reorient(true, true);
+pathItem.getIntersections(path);
+pathItem.getIntersections(path, callback);
+pathItem.getCrossings(path);
+pathItem.getNearestLocation(point);
+pathItem.getNearestPoint(point);
+pathItem.reverse();
+pathItem.flatten();
+pathItem.flatten(0);
+pathItem.smooth();
+pathItem.smooth({});
+pathItem.simplify();
+pathItem.simplify(0);
+pathItem.interpolate(path, path, 0);
+pathItem.compare(path);
+pathItem.moveTo(point);
+pathItem.lineTo(point);
+pathItem.arcTo(point, point);
+pathItem.arcTo(point);
+pathItem.arcTo(point, true);
+pathItem.curveTo(point, point);
+pathItem.curveTo(point, point, 0);
+pathItem.cubicCurveTo(point, point, point);
+pathItem.quadraticCurveTo(point, point);
+pathItem.closePath();
+pathItem.moveBy(point);
+pathItem.lineBy(point);
+pathItem.arcBy(point, point);
+pathItem.arcBy(point);
+pathItem.arcBy(point, true);
+pathItem.curveBy(point, point);
+pathItem.curveBy(point, point, 0);
+pathItem.cubicCurveBy(point, point, point);
+pathItem.quadraticCurveBy(point, point);
+paper.PathItem.create('');
+paper.PathItem.create([ [ 0 ] ]);
+paper.PathItem.create({});
+
+
+//
+// Path
+//
+
+new paper.Path();
+new paper.Path([ segment ]);
+new paper.Path(object);
+new paper.Path('');
+new paper.Path.Line(point, point);
+new paper.Path.Line(object);
+new paper.Path.Circle(point, 0);
+new paper.Path.Circle(object);
+new paper.Path.Rectangle(rectangle);
+new paper.Path.Rectangle(rectangle, size);
+new paper.Path.Rectangle(point, size);
+new paper.Path.Rectangle(point, point);
+new paper.Path.Rectangle(object);
+new paper.Path.Ellipse(rectangle);
+new paper.Path.Ellipse(object);
+new paper.Path.Arc(point, point, point);
+new paper.Path.Arc(object);
+new paper.Path.RegularPolygon(point, 0, 0);
+new paper.Path.RegularPolygon(object);
+new paper.Path.Star(point, 0, 0, 0);
+new paper.Path.Star(object);
+path.segments;
+path.firstSegment;
+path.lastSegment;
+path.curves;
+path.firstCurve;
+path.lastCurve;
+path.closed;
+path.length;
+path.area;
+path.fullySelected;
+path.add(segment);
+path.insert(0, segment);
+path.addSegments([ segment ]);
+path.insertSegments(0, [ segment ]);
+path.removeSegment(0);
+path.removeSegments();
+path.removeSegments(0);
+path.removeSegments(0, 0);
+path.hasHandles();
+path.clearHandles();
+path.divideAt(curveLocation);
+path.splitAt(curveLocation);
+path.join(path);
+path.join(path, 0);
+path.reduce(object);
+path.toShape();
+path.toShape(true);
+path.getLocationOf(point);
+path.getOffsetOf(point);
+path.getLocationAt(0);
+path.getPointAt(0);
+path.getTangentAt(0);
+path.getNormalAt(0);
+path.getWeightedTangentAt(0);
+path.getWeightedNormalAt(0);
+path.getCurvatureAt(0);
+path.getOffsetsWithTangent(point);
+
+
+//
+// CompoundPath
+//
+
+new paper.CompoundPath(object);
+new paper.CompoundPath('');
+compoundPath.closed;
+compoundPath.firstSegment;
+compoundPath.lastSegment;
+compoundPath.curves;
+compoundPath.firstCurve;
+compoundPath.lastCurve;
+compoundPath.area;
+compoundPath.length;
+
+
+//
+// Segment
+//
+
+new paper.Segment();
+new paper.Segment(point);
+new paper.Segment(point, point);
+new paper.Segment(point, point, point);
+new paper.Segment(object);
+segment.point;
+segment.handleIn;
+segment.handleOut;
+segment.selected;
+segment.index;
+segment.path;
+segment.curve;
+segment.location;
+segment.next;
+segment.previous;
+segment.hasHandles();
+segment.isSmooth();
+segment.clearHandles();
+segment.smooth();
+segment.smooth(object);
+segment.isFirst();
+segment.isLast();
+segment.reverse();
+segment.reversed();
+segment.remove();
+segment.toString();
+segment.transform(matrix);
+segment.interpolate(segment, segment, 0);
+
+
+//
+// Curve
+//
+
+new paper.Curve(segment, segment);
+new paper.Curve(point, point, point, point);
+curve.point1;
+curve.point2;
+curve.handle1;
+curve.handle2;
+curve.segment1;
+curve.segment2;
+curve.path;
+curve.index;
+curve.next;
+curve.previous;
+curve.selected;
+curve.values;
+curve.points;
+curve.length;
+curve.area;
+curve.bounds;
+curve.strokeBounds;
+curve.handleBounds;
+curve.clone();
+curve.toString();
+curve.classify();
+curve.remove();
+curve.isFirst();
+curve.isLast();
+curve.getPart(0, 0);
+curve.divideAt(curveLocation);
+curve.divideAtTime(0);
+curve.splitAt(curveLocation);
+curve.splitAtTime(0);
+curve.reversed();
+curve.clearHandles();
+curve.hasHandles();
+curve.hasLength();
+curve.hasLength(0);
+curve.isStraight();
+curve.isLinear();
+curve.isCollinear(curve);
+curve.isHorizontal();
+curve.isVertical();
+curve.getLocationAt(0);
+curve.getLocationAtTime(0);
+curve.getTimeAt(0);
+curve.getTimeAt(0, 0);
+curve.getTimesWithTangent(point);
+curve.getOffsetAtTime(0);
+curve.getLocationOf(point);
+curve.getOffsetOf(point);
+curve.getTimeOf(point);
+curve.getNearestLocation(point);
+curve.getNearestPoint(point);
+curve.getPointAt(curveLocation);
+curve.getTangentAt(curveLocation);
+curve.getNormalAt(curveLocation);
+curve.getWeightedTangentAt(curveLocation);
+curve.getWeightedNormalAt(curveLocation);
+curve.getCurvatureAt(curveLocation);
+curve.getPointAtTime(0);
+curve.getTangentAtTime(0);
+curve.getNormalAtTime(0);
+curve.getWeightedTangentAtTime(0);
+curve.getWeightedNormalAtTime(0);
+curve.getCurvatureAtTime(0);
+curve.getIntersections(curve);
+
+
+//
+// CurveLocation
+//
+
+new paper.CurveLocation(curve, 0);
+new paper.CurveLocation(curve, 0, point);
+curveLocation.segment;
+curveLocation.curve;
+curveLocation.path;
+curveLocation.index;
+curveLocation.time;
+curveLocation.point;
+curveLocation.offset;
+curveLocation.curveOffset;
+curveLocation.intersection;
+curveLocation.tangent;
+curveLocation.normal;
+curveLocation.curvature;
+curveLocation.distance;
+curveLocation.equals(curveLocation);
+curveLocation.toString();
+curveLocation.isTouching();
+curveLocation.isCrossing();
+curveLocation.hasOverlap();
+
+
+//
+// SymbolDefinition
+//
+
+new paper.SymbolDefinition(item);
+new paper.SymbolDefinition(item, true);
+symbolDefinition.project;
+symbolDefinition.item;
+symbolDefinition.place();
+symbolDefinition.place(point);
+symbolDefinition.clone();
+symbolDefinition.equals(symbolDefinition);
+
+
+//
+// SymbolItem
+//
+
+new paper.SymbolItem(symbolDefinition);
+new paper.SymbolItem(item);
+new paper.SymbolItem(symbolDefinition, point);
+symbolItem.definition;
+
+
+//
+// Style
+//
+
+new paper.Style(object);
+style.view;
+style.strokeColor;
+style.strokeWidth;
+style.strokeCap;
+style.strokeJoin;
+style.strokeScaling;
+style.dashOffset;
+style.dashArray;
+style.miterLimit;
+style.fillColor;
+style.fillRule;
+style.shadowColor;
+style.shadowBlur;
+style.shadowOffset;
+style.selectedColor;
+style.fontFamily;
+style.fontWeight;
+style.fontSize;
+style.leading;
+style.justification;
+
+
+//
+// Color
+//
+
+new paper.Color(0, 0, 0);
+new paper.Color(0, 0, 0, 0);
+new paper.Color(0);
+new paper.Color(0, 0);
+new paper.Color(object);
+new paper.Color('');
+new paper.Color(gradient, point, point);
+new paper.Color(gradient, point, point, point);
+color.type;
+color.components;
+color.alpha;
+color.red;
+color.green;
+color.blue;
+color.gray;
+color.hue;
+color.saturation;
+color.brightness;
+color.lightness;
+color.gradient;
+color.highlight;
+color.set(0, 0, 0);
+color.set(0, 0, 0, 0);
+color.set(0);
+color.set(0, 0);
+color.set(object);
+color.set(color);
+color.set(gradient, point, point);
+color.set(gradient, point, point, point);
+color.convert('');
+color.hasAlpha();
+color.equals(color);
+color.clone();
+color.toString();
+color.toCSS(true);
+color.transform(matrix);
+color.add(0);
+color.add(color);
+color.subtract(0);
+color.subtract(color);
+color.multiply(0);
+color.multiply(color);
+color.divide(0);
+color.divide(color);
+paper.Color.random();
+
+
+//
+// Gradient
+//
+
+gradient.stops;
+gradient.radial;
+gradient.clone();
+gradient.equals(gradient);
+
+
+//
+// GradientStop
+//
+
+new paper.GradientStop();
+new paper.GradientStop(color);
+new paper.GradientStop(color, 0);
+gradientStop.offset;
+gradientStop.color;
+gradientStop.clone();
+
+
+//
+// TextItem
+//
+
+textItem.content;
+textItem.fontFamily;
+textItem.fontWeight;
+textItem.fontSize;
+textItem.leading;
+textItem.justification;
+
+
+//
+// PointText
+//
+
+new paper.PointText(point);
+new paper.PointText(object);
+pointText.point;
+
+
+//
+// View
+//
+
+view.autoUpdate;
+view.element;
+view.pixelRatio;
+view.resolution;
+view.viewSize;
+view.bounds;
+view.size;
+view.center;
+view.zoom;
+view.rotation;
+view.scaling;
+view.matrix;
+view.onFrame;
+view.onResize;
+view.onMouseDown;
+view.onMouseDrag;
+view.onMouseUp;
+view.onClick;
+view.onDoubleClick;
+view.onMouseMove;
+view.onMouseEnter;
+view.onMouseLeave;
+view.remove();
+view.update();
+view.requestUpdate();
+view.play();
+view.pause();
+view.isVisible();
+view.isInserted();
+view.translate(point);
+view.rotate(0);
+view.rotate(0, point);
+view.scale(0);
+view.scale(0, point);
+view.scale(0, 0);
+view.scale(0, 0, point);
+view.shear(point);
+view.shear(point, point);
+view.shear(0, 0);
+view.shear(0, 0, point);
+view.skew(point);
+view.skew(point, point);
+view.skew(0, 0);
+view.skew(0, 0, point);
+view.transform(matrix);
+view.projectToView(point);
+view.viewToProject(point);
+view.getEventPoint(event);
+view.on('', callback);
+view.on(object);
+view.off('', callback);
+view.off(object);
+view.emit('', event);
+view.responds('');
+
+
+//
+// Event
+//
+
+event.timeStamp;
+event.modifiers;
+event.preventDefault();
+event.stopPropagation();
+event.stop();
+
+
+//
+// MouseEvent
+//
+
+mouseEvent.type;
+mouseEvent.point;
+mouseEvent.target;
+mouseEvent.currentTarget;
+mouseEvent.delta;
+mouseEvent.toString();
+
+
+//
+// Tool
+//
+
+tool.minDistance;
+tool.maxDistance;
+tool.fixedDistance;
+tool.onMouseDown;
+tool.onMouseDrag;
+tool.onMouseMove;
+tool.onMouseUp;
+tool.onKeyDown;
+tool.onKeyUp;
+tool.activate();
+tool.remove();
+tool.on('', callback);
+tool.on(object);
+tool.off('', callback);
+tool.off(object);
+tool.emit('', event);
+tool.responds('');
+
+
+//
+// ToolEvent
+//
+
+toolEvent.type;
+toolEvent.point;
+toolEvent.lastPoint;
+toolEvent.downPoint;
+toolEvent.middlePoint;
+toolEvent.delta;
+toolEvent.count;
+toolEvent.item;
+toolEvent.toString();
+
+
+//
+// Key
+//
+
+paper.Key.modifiers;
+paper.Key.isDown('');
+
+
+//
+// KeyEvent
+//
+
+keyEvent.type;
+keyEvent.character;
+keyEvent.key;
+keyEvent.toString();
+
+
+//
+// PaperScope
+//
+
+new paper.PaperScope();
+paperScope.version;
+paperScope.settings;
+paperScope.project;
+paperScope.projects;
+paperScope.view;
+paperScope.tool;
+paperScope.tools;
+paperScope.execute('');
+paperScope.execute('', object);
+paperScope.install(object);
+paperScope.setup('');
+paperScope.setup({} as HTMLCanvasElement);
+paperScope.setup(size);
+paperScope.activate();
+paper.PaperScope.get(0);
+
+
+//
+// PaperScript
+//
+
+paper.PaperScript.compile('');
+paper.PaperScript.compile('', object);
+paper.PaperScript.execute('', paperScope);
+paper.PaperScript.execute('', paperScope, object);
+paper.PaperScript.load();
+paper.PaperScript.load({} as HTMLScriptElement);
diff --git a/package.json b/package.json
index 95756b2b..5471766d 100644
--- a/package.json
+++ b/package.json
@@ -52,6 +52,7 @@
     "jshint-summary": "^0.4.0",
     "merge-stream": "^1.0.0",
     "minimist": "^1.2.0",
+    "mustache": "^3.0.1",
     "prepro": "^2.4.0",
     "qunitjs": "^1.23.0",
     "require-dir": "^0.3.0",
@@ -59,7 +60,8 @@
     "run-sequence": "^1.2.2",
     "source-map-support": "^0.4.0",
     "stats.js": "0.16.0",
-    "straps": "^3.0.1"
+    "straps": "^3.0.1",
+    "typescript": "^3.1.6"
   },
   "browser": {
     "canvas": false,
diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index 6d695445..070578c5 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -104,6 +104,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * also work for calls of `set()`.
      *
      * @function
+     * @param {...*} value
      * @return {Point}
      */
     set: '#initialize',
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 066be97a..9cc4dfb8 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -170,6 +170,7 @@ var Point = Base.extend(/** @lends Point# */{
      * for calls of `set()`.
      *
      * @function
+     * @param {...*} value
      * @return {Point}
      */
     set: '#initialize',
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index 72f93dff..4be507aa 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -159,6 +159,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * constructors also work for calls of `set()`.
      *
      * @function
+     * @param {...*} value
      * @return {Rectangle}
      */
     set: '#initialize',
diff --git a/src/basic/Size.js b/src/basic/Size.js
index 219528ab..502276f6 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -130,6 +130,7 @@ var Size = Base.extend(/** @lends Size# */{
      * for calls of `set()`.
      *
      * @function
+     * @param {...*} value
      * @return {Size}
      */
     set: '#initialize',
diff --git a/src/style/Color.js b/src/style/Color.js
index 86c0765c..dfb62a58 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -691,6 +691,7 @@ var Color = Base.extend(new function() {
          * constructors also work for calls of `set()`.
          *
          * @function
+         * @param {...*} value
          * @return {Color}
          */
         set: '#initialize',

From f25690aa91b5b8bb6fc290f01bb7e008e5c7a5c3 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 3 Dec 2018 13:53:30 +0100
Subject: [PATCH 041/181] Rename type definition file to `paper.d.ts`.

---
 gulp/tasks/dist.js                                 | 2 +-
 gulp/tasks/docs.js                                 | 2 +-
 gulp/typescript/typescript-definition-generator.js | 2 +-
 gulp/typescript/typescript-definition-test.ts      | 2 +-
 package.json                                       | 1 +
 5 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index 3d323b99..5d41cc91 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -22,7 +22,7 @@ gulp.task('zip', ['clean:zip', 'dist'], function() {
             gulp.src([
                 'dist/paper-full*.js',
                 'dist/paper-core*.js',
-                'dist/index.d.ts',
+                'dist/paper.d.ts',
                 'dist/node/**/*',
                 'LICENSE.txt',
                 'examples/**/*',
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index 9459f5d0..30bd2050 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -59,7 +59,7 @@ gulp.task('docs:typescript', function() {
 });
 // First clean eventually existing type definition...
 gulp.task('docs:typescript:clean:before', function() {
-    return del('dist/index.d.ts');
+    return del('dist/paper.d.ts');
 });
 // ...then build the definition...
 gulp.task('docs:typescript:build', function() {
diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
index e4dfda30..3af53cda 100644
--- a/gulp/typescript/typescript-definition-generator.js
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -115,7 +115,7 @@ const template = fs.readFileSync(__dirname + '/typescript-definition-template.mu
 // Render template.
 const output = mustache.render(template, context);
 // Write output in a file.
-fs.writeFileSync(__dirname + '/../../dist/index.d.ts', output, 'utf8');
+fs.writeFileSync(__dirname + '/../../dist/paper.d.ts', output, 'utf8');
 
 
 //
diff --git a/gulp/typescript/typescript-definition-test.ts b/gulp/typescript/typescript-definition-test.ts
index 22431122..ee06d975 100644
--- a/gulp/typescript/typescript-definition-test.ts
+++ b/gulp/typescript/typescript-definition-test.ts
@@ -1,4 +1,4 @@
-/// <reference path="../../dist/index.d.ts" />
+/// <reference path="../../dist/paper.d.ts" />
 
 /**
  * This file is used as a way to test auto-generated typescript definition
diff --git a/package.json b/package.json
index 5471766d..5838bd08 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,7 @@
   "bugs": "https://github.com/paperjs/paper.js/issues",
   "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
   "main": "dist/paper-full.js",
+  "types": "dist/paper.d.ts",
   "scripts": {
     "precommit": "gulp jshint --branch develop",
     "prepush": "gulp test --branch develop",

From b8a0743e3d61c85de617a6d0ef2ab18990614af8 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 3 Dec 2018 14:03:24 +0100
Subject: [PATCH 042/181] Avoid using `_` as parameter name.

---
 .../typescript-definition-generator.js        | 76 +++++++++----------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
index 3af53cda..eac10f7a 100644
--- a/gulp/typescript/typescript-definition-generator.js
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -25,40 +25,40 @@ classes.forEach(cls => {
     cls.comment = formatComment(cls.comment, 'class');
 
     // Build a filter for deprecated or inherited methods or properties.
-    const filter = _ => !_.deprecated && _.memberOf == cls.alias && !_.isNamespace;
+    const filter = it => !it.deprecated && it.memberOf == cls.alias && !it.isNamespace;
 
     // Format properties.
     cls.properties = cls.properties
         .filter(filter)
-        .map(_ => ({
-            name: _._name,
-            type: formatType(_.type),
-            static: formatStatic(_.isStatic),
-            readOnly: formatReadOnly(_.readOnly),
-            comment: formatComment(_.comment)
+        .map(it => ({
+            name: it._name,
+            type: formatType(it.type),
+            static: formatStatic(it.isStatic),
+            readOnly: formatReadOnly(it.readOnly),
+            comment: formatComment(it.comment)
         }));
 
     // Format methods.
     const methods = cls.methods
         .filter(filter)
-        .map(_ => {
-            const name = formatMethodName(_._name);
-            const isStaticConstructor = _.isStatic && _.isConstructor;
+        .map(it => {
+            const name = formatMethodName(it._name);
+            const isStaticConstructor = it.isStatic && it.isConstructor;
             return {
                 name: name,
                 // Constructors don't need return type.
-                type: !_.isConstructor
-                    ? formatType(getMethodReturnType(_), true)
+                type: !it.isConstructor
+                    ? formatType(getMethodReturnType(it), true)
                     : '',
-                static: formatStatic(_.isStatic),
+                static: formatStatic(it.isStatic),
                 // This flag is only used below to filter methods.
                 isStaticConstructor: isStaticConstructor,
-                comment: formatComment(_.comment, 'desc', _.isConstructor),
-                params: _._params
-                    ? _._params
+                comment: formatComment(it.comment, 'desc', it.isConstructor),
+                params: it._params
+                    ? it._params
                     // Filter internal parameters (starting with underscore).
-                        .filter(_ => !/^_/.test(_.name))
-                        .map(_ => formatParameter(_, isStaticConstructor && cls))
+                        .filter(it => !/^_/.test(it.name))
+                        .map(it => formatParameter(it, isStaticConstructor && cls))
                         .join(', ')
                     : ''
             };
@@ -72,7 +72,7 @@ classes.forEach(cls => {
     methods.forEach(method => {
         if (method.isStaticConstructor) {
             // Group static constructors by method name.
-            let staticConstructors = cls.staticConstructors.find(_ => _.name === method.name);
+            let staticConstructors = cls.staticConstructors.find(it => it.name === method.name);
             if (!staticConstructors) {
                 staticConstructors = {
                     name: method.name,
@@ -92,11 +92,11 @@ classes.forEach(cls => {
 // Format global vriables.
 globals = globals
 // Filter global variables that make no sense in type definition.
-    .filter(_ => !/^on/.test(_._name) && _._name !== 'paper')
-    .map(_ => ({
-        name: _._name,
-        type: formatType(_.type),
-        comment: formatComment(_.comment)
+    .filter(it => !/^on/.test(it._name) && it._name !== 'paper')
+    .map(it => ({
+        name: it._name,
+        type: formatType(it.type),
+        comment: formatComment(it.comment)
     }));
 
 // Format data trough a mustache template.
@@ -162,7 +162,7 @@ function parseType(type, isMethodReturnType, staticConstructorClass) {
         // `rectangle` parameter type must be mapped to `paper.Rectangle` as it
         // is declared inside a `Path` namespace and would otherwise be wrongly
         // assumed as being the type of `Path.Rectangle` class.
-        if (staticConstructorClass && staticConstructorClass.methods.find(_ => _.isStatic && _.isConstructor && formatMethodName(_._name) === singleType)
+        if (staticConstructorClass && staticConstructorClass.methods.find(it => it.isStatic && it.isConstructor && formatMethodName(it._name) === singleType)
         ) {
             return 'paper.' + type;
         }
@@ -183,19 +183,19 @@ function formatMethodName(methodName) {
     return methodName;
 }
 
-function formatParameter(_, staticConstructorClass) {
+function formatParameter(param, staticConstructorClass) {
     let content = '';
     // Handle rest parameter pattern `...Type`. Parameter name needs to be
     // prefixed with `...` as in ES6. E.g. `...parameter: type[]`.
-    if (_.type.match(/^\.\.\.(.+)$/)) {
+    if (param.type.match(/^\.\.\.(.+)$/)) {
         content += '...';
     }
-    content += formatParameterName(_.name);
+    content += formatParameterName(param.name);
     // Optional parameters are formatted as: `parameter?: type`.
-    if (_.isOptional) {
+    if (param.isOptional) {
         content += '?';
     }
-    content += formatType(_.type, false, staticConstructorClass);
+    content += formatType(param.type, false, staticConstructorClass);
     return content;
 }
 
@@ -213,7 +213,7 @@ function formatComment(comment, descriptionTagName = 'desc', skipReturn = false)
     let content = '';
 
     // Retrieve description tag.
-    const descriptionTag = tags.find(_ => _.title === descriptionTagName);
+    const descriptionTag = tags.find(it => it.title === descriptionTagName);
     if (descriptionTag) {
         // Don't display group titles.
         content += descriptionTag.desc.replace(/\{@grouptitle .+?\}/g, '').trim();
@@ -225,10 +225,10 @@ function formatComment(comment, descriptionTagName = 'desc', skipReturn = false)
     // provided in the signature...
     content += formatCommentTags(tags, 'see');
     content += formatCommentTags(tags, 'option');
-    content += formatCommentTags(tags, 'param', _ => _.name + ' - ' + _.desc);
+    content += formatCommentTags(tags, 'param', it => it.name + ' - ' + it.desc);
 
     if (!skipReturn) {
-        content += formatCommentTags(tags, 'return', _ => _.desc.trim().replace(/^\{|\}$/g, '').replace(/@([a-zA-Z]+)/, '$1'));
+        content += formatCommentTags(tags, 'return', it => it.desc.trim().replace(/^\{|\}$/g, '').replace(/@([a-zA-Z]+)/, '$1'));
     }
 
     // Make sure links are followable (e.g. by IDEs) by removing parameters.
@@ -242,13 +242,13 @@ function formatComment(comment, descriptionTagName = 'desc', skipReturn = false)
 function formatCommentTags(tags, tagName, formatter) {
     let content = '';
     // Default formatter simply outputs description.
-    formatter = formatter || (_ => _.desc);
+    formatter = formatter || (it => it.desc);
     // Only keep tags that have a description.
-    tags = tags.filter(_ => _.desc && _.title === tagName);
+    tags = tags.filter(it => it.desc && it.title === tagName);
     if (tags.length > 0) {
         content += '\n';
         // Display tag as it was in original JSDoc, followed by formatted value.
-        tags.forEach(_ => content += '\n@' + tagName + ' ' + formatter(_));
+        tags.forEach(it => content += '\n@' + tagName + ' ' + formatter(it));
     }
     return content;
 }
@@ -284,8 +284,8 @@ function formatJSDoc(offset, render) {
     return '/** \n' + content + '\n' + indentation + ' */';
 }
 
-function getMethodReturnType(_) {
-    return _.returnType || _.returns.length > 0 && _.returns[0].type;
+function getMethodReturnType(method) {
+    return method.returnType || method.returns.length > 0 && method.returns[0].type;
 }
 
 function sortMethods(methodA, methodB) {

From a7c2fb3ddf594501e3f19d8d320531111a03b2ff Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 3 Dec 2018 14:46:50 +0100
Subject: [PATCH 043/181] Improve `Color.random()` documentation.

---
 src/style/Color.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/style/Color.js b/src/style/Color.js
index dfb62a58..b398f30c 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -1186,9 +1186,10 @@ var Color = Base.extend(new function() {
             _types: types,
 
             /**
-             * Creates a random color.
+             * Returns a color object with random {@link #red}, {@link #green}
+             * and {@link #blue} values between `0` and `1`.
              *
-             * @return {Color} the randomly created color
+             * @return {Color} the newly created color object
              * @static
              *
              * @example {@paperscript}

From 449c5c3e6d457e9d7523bff86cf5e7a4757e6088 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 3 Dec 2018 15:04:22 +0100
Subject: [PATCH 044/181] Fix `Tween#then()` documentation.

Bug introduced in 9c684091f42675043e0135ae31a4155b96901b5a: example
variable was renamed from `item` to `circle` in declaration but later
calls were still done with `item`.
---
 src/anim/Tween.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index d3da643e..d7e04c86 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -147,15 +147,19 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      *     completes
      * @return {Tween}
      *
-     * @example {@paperscript} // Tweens chaining: var circle = new
-     * Path.Circle({center: view.center, radius: 40, fillColor: 'blue'
+     * @example {@paperscript}
+     * // Tweens chaining:
+     * var circle = new Path.Circle({
+     *     center: view.center,
+     *     radius: 40,
+     *     fillColor: 'blue'
      * });
      * // Tween color from blue to red.
-     * var tween = item.tweenTo({ fillColor: 'red' }, 2000);
+     * var tween = circle.tweenTo({ fillColor: 'red' }, 2000);
      * // When the first tween completes...
      * tween.then(function() {
      *     // ...tween color back to blue.
-     *     item.tweenTo({ fillColor: 'blue' }, 2000);
+     *     circle.tweenTo({ fillColor: 'blue' }, 2000);
      * });
      */
     then: function(then) {

From 5904a288e74f68787610672c84a02ed65b7cbbbb Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Thu, 13 Dec 2018 16:48:35 +0900
Subject: [PATCH 045/181] Fix css color parse

---
 CHANGELOG.md        | 6 ++++++
 src/style/Color.js  | 2 +-
 test/tests/Color.js | 3 +++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c32cead7..03c89576 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Change Log
 
+## Prebuilt version
+
+### Fixed
+
+- Fix css color parse (#1629)
+
 ## `0.12.0`
 
 ### News
diff --git a/src/style/Color.js b/src/style/Color.js
index b398f30c..c4ff5fd4 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -80,7 +80,7 @@ var Color = Base.extend(new function() {
         } else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
             // RGB / RGBA or HSL / HSLA
             type = match[1];
-            components = match[2].split(/[,\s]+/g);
+            components = match[2].trim().split(/[,\s]+/g);
             var isHSL = type === 'hsl';
             for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
                 var component = components[i];
diff --git a/test/tests/Color.js b/test/tests/Color.js
index e1bacfd8..ade52127 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -81,6 +81,9 @@ test('Creating Colors', function() {
     equals(new Color('rgba(255, 0, 0, 0.5)'), new Color(1, 0, 0, 0.5),
             'Color from rgba() string');
 
+    equals(new Color('rgba( 255, 0, 0, 0.5 )'), new Color(1, 0, 0, 0.5),
+            'Color from rgba() string 2nd test');
+
     equals(new Color('hsl(180deg, 20%, 40%)'),
             new Color({ hue: 180, saturation: 0.2, lightness: 0.4 }),
             'Color from hsl() string');

From be4199b6ebcc45dc0303d209dd72adfb2cc32c2d Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Thu, 27 Dec 2018 16:13:01 +0900
Subject: [PATCH 046/181] Update copyright year to 2019

---
 LICENSE.txt                                             | 2 +-
 gulp/tasks/build.js                                     | 2 +-
 gulp/tasks/dist.js                                      | 2 +-
 gulp/tasks/docs.js                                      | 2 +-
 gulp/tasks/jshint.js                                    | 2 +-
 gulp/tasks/load.js                                      | 2 +-
 gulp/tasks/minify.js                                    | 2 +-
 gulp/tasks/publish.js                                   | 2 +-
 gulp/tasks/test.js                                      | 2 +-
 gulp/tasks/watch.js                                     | 2 +-
 gulp/typescript/typescript-definition-template.mustache | 2 +-
 gulp/utils/error.js                                     | 2 +-
 gulp/utils/options.js                                   | 2 +-
 gulpfile.js                                             | 2 +-
 src/anim/Tween.js                                       | 2 +-
 src/basic/Line.js                                       | 2 +-
 src/basic/Matrix.js                                     | 2 +-
 src/basic/Point.js                                      | 2 +-
 src/basic/Rectangle.js                                  | 2 +-
 src/basic/Size.js                                       | 2 +-
 src/canvas/BlendMode.js                                 | 2 +-
 src/canvas/CanvasProvider.js                            | 2 +-
 src/canvas/ProxyContext.js                              | 2 +-
 src/constants.js                                        | 2 +-
 src/core/Base.js                                        | 2 +-
 src/core/Emitter.js                                     | 2 +-
 src/core/PaperScope.js                                  | 2 +-
 src/core/PaperScopeItem.js                              | 2 +-
 src/core/PaperScript.js                                 | 2 +-
 src/docs/global.js                                      | 2 +-
 src/dom/DomElement.js                                   | 2 +-
 src/dom/DomEvent.js                                     | 2 +-
 src/event/Event.js                                      | 2 +-
 src/event/Key.js                                        | 2 +-
 src/event/KeyEvent.js                                   | 2 +-
 src/event/MouseEvent.js                                 | 2 +-
 src/export.js                                           | 2 +-
 src/init.js                                             | 2 +-
 src/item/ChangeFlag.js                                  | 2 +-
 src/item/Group.js                                       | 2 +-
 src/item/HitResult.js                                   | 2 +-
 src/item/Item.js                                        | 2 +-
 src/item/ItemSelection.js                               | 2 +-
 src/item/Layer.js                                       | 2 +-
 src/item/Project.js                                     | 2 +-
 src/item/Raster.js                                      | 2 +-
 src/item/Shape.js                                       | 2 +-
 src/item/SymbolDefinition.js                            | 2 +-
 src/item/SymbolItem.js                                  | 2 +-
 src/load.js                                             | 2 +-
 src/net/Http.js                                         | 2 +-
 src/node/canvas.js                                      | 2 +-
 src/node/extend.js                                      | 2 +-
 src/node/self.js                                        | 2 +-
 src/node/xml.js                                         | 2 +-
 src/options.js                                          | 2 +-
 src/paper.js                                            | 4 ++--
 src/path/CompoundPath.js                                | 2 +-
 src/path/Curve.js                                       | 2 +-
 src/path/CurveLocation.js                               | 2 +-
 src/path/Path.Constructors.js                           | 2 +-
 src/path/Path.js                                        | 2 +-
 src/path/PathFitter.js                                  | 2 +-
 src/path/PathFlattener.js                               | 2 +-
 src/path/PathItem.Boolean.js                            | 2 +-
 src/path/PathItem.js                                    | 2 +-
 src/path/Segment.js                                     | 2 +-
 src/path/SegmentPoint.js                                | 2 +-
 src/path/SegmentSelection.js                            | 2 +-
 src/style/Color.js                                      | 2 +-
 src/style/Gradient.js                                   | 2 +-
 src/style/GradientStop.js                               | 2 +-
 src/style/Style.js                                      | 2 +-
 src/svg/SvgElement.js                                   | 2 +-
 src/svg/SvgExport.js                                    | 2 +-
 src/svg/SvgImport.js                                    | 2 +-
 src/svg/SvgStyles.js                                    | 2 +-
 src/text/PointText.js                                   | 2 +-
 src/text/TextItem.js                                    | 2 +-
 src/tool/Tool.js                                        | 2 +-
 src/tool/ToolEvent.js                                   | 2 +-
 src/util/Formatter.js                                   | 2 +-
 src/util/Numerical.js                                   | 2 +-
 src/util/UID.js                                         | 2 +-
 src/view/CanvasView.js                                  | 2 +-
 src/view/View.js                                        | 2 +-
 test/helpers.js                                         | 2 +-
 test/load.js                                            | 2 +-
 test/tests/Color.js                                     | 2 +-
 test/tests/CompoundPath.js                              | 2 +-
 test/tests/Curve.js                                     | 2 +-
 test/tests/CurveLocation.js                             | 2 +-
 test/tests/Emitter.js                                   | 2 +-
 test/tests/Group.js                                     | 2 +-
 test/tests/HitResult.js                                 | 2 +-
 test/tests/Interactions.js                              | 2 +-
 test/tests/Item.js                                      | 2 +-
 test/tests/Item_Bounds.js                               | 2 +-
 test/tests/Item_Cloning.js                              | 2 +-
 test/tests/Item_Getting.js                              | 2 +-
 test/tests/Item_Order.js                                | 2 +-
 test/tests/JSON.js                                      | 2 +-
 test/tests/Layer.js                                     | 2 +-
 test/tests/Matrix.js                                    | 2 +-
 test/tests/Numerical.js                                 | 2 +-
 test/tests/Path.js                                      | 2 +-
 test/tests/PathItem.js                                  | 2 +-
 test/tests/PathItem_Contains.js                         | 2 +-
 test/tests/Path_Boolean.js                              | 2 +-
 test/tests/Path_Constructors.js                         | 2 +-
 test/tests/Path_Intersections.js                        | 2 +-
 test/tests/Point.js                                     | 2 +-
 test/tests/Project.js                                   | 2 +-
 test/tests/Raster.js                                    | 2 +-
 test/tests/Rectangle.js                                 | 2 +-
 test/tests/Segment.js                                   | 2 +-
 test/tests/Shape.js                                     | 2 +-
 test/tests/Size.js                                      | 2 +-
 test/tests/Style.js                                     | 2 +-
 test/tests/SvgExport.js                                 | 2 +-
 test/tests/SvgImport.js                                 | 2 +-
 test/tests/SymbolItem.js                                | 2 +-
 test/tests/TextItem.js                                  | 2 +-
 test/tests/load.js                                      | 2 +-
 travis/deploy-prebuilt.sh                               | 2 +-
 travis/install-assets.sh                                | 2 +-
 travis/setup-git.sh                                     | 2 +-
 127 files changed, 128 insertions(+), 128 deletions(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index 2a3d5bee..6b6c439e 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
 http://scratchdisk.com/ & https://puckey.studio/
 All rights reserved.
 
diff --git a/gulp/tasks/build.js b/gulp/tasks/build.js
index ca69f4bf..48ee18ca 100644
--- a/gulp/tasks/build.js
+++ b/gulp/tasks/build.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index 5d41cc91..e69e861c 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index 30bd2050..d893eae2 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/jshint.js b/gulp/tasks/jshint.js
index fa8e5481..987c96f4 100644
--- a/gulp/tasks/jshint.js
+++ b/gulp/tasks/jshint.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/load.js b/gulp/tasks/load.js
index 02740345..d985e74a 100644
--- a/gulp/tasks/load.js
+++ b/gulp/tasks/load.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/minify.js b/gulp/tasks/minify.js
index 1ce1f790..28d1b1aa 100644
--- a/gulp/tasks/minify.js
+++ b/gulp/tasks/minify.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index f5ea1f92..73d36d78 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/test.js b/gulp/tasks/test.js
index 0e42b641..328db819 100644
--- a/gulp/tasks/test.js
+++ b/gulp/tasks/test.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/tasks/watch.js b/gulp/tasks/watch.js
index 441265af..28a4dbdd 100644
--- a/gulp/tasks/watch.js
+++ b/gulp/tasks/watch.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/typescript/typescript-definition-template.mustache b/gulp/typescript/typescript-definition-template.mustache
index a7856e17..1065b606 100644
--- a/gulp/typescript/typescript-definition-template.mustache
+++ b/gulp/typescript/typescript-definition-template.mustache
@@ -2,7 +2,7 @@
  * Paper.js v{{version}} - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/utils/error.js b/gulp/utils/error.js
index 3ce10e2d..b61b9a82 100644
--- a/gulp/utils/error.js
+++ b/gulp/utils/error.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulp/utils/options.js b/gulp/utils/options.js
index 654978f7..7fd7bd0c 100644
--- a/gulp/utils/options.js
+++ b/gulp/utils/options.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/gulpfile.js b/gulpfile.js
index bbde60cf..ecb7f8d1 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index d7e04c86..eb3cc02c 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/basic/Line.js b/src/basic/Line.js
index 4b88fd96..84893fd8 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index 070578c5..e4f84bf8 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 9cc4dfb8..9af0c644 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index 4be507aa..5aab625d 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/basic/Size.js b/src/basic/Size.js
index 502276f6..dad849b3 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/canvas/BlendMode.js b/src/canvas/BlendMode.js
index a147bc2b..ac9ea7d3 100644
--- a/src/canvas/BlendMode.js
+++ b/src/canvas/BlendMode.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/canvas/CanvasProvider.js b/src/canvas/CanvasProvider.js
index 40460759..3ac0aac0 100644
--- a/src/canvas/CanvasProvider.js
+++ b/src/canvas/CanvasProvider.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/canvas/ProxyContext.js b/src/canvas/ProxyContext.js
index 1d3b540f..5a403b48 100644
--- a/src/canvas/ProxyContext.js
+++ b/src/canvas/ProxyContext.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/constants.js b/src/constants.js
index 7c54cdee..0c84dbcf 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/core/Base.js b/src/core/Base.js
index 2d2a4a13..dce8d049 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/core/Emitter.js b/src/core/Emitter.js
index 6ecb482a..0e9724d1 100644
--- a/src/core/Emitter.js
+++ b/src/core/Emitter.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 4bb5c42f..b6c2970d 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/core/PaperScopeItem.js b/src/core/PaperScopeItem.js
index f0381ba8..8aa31a8b 100644
--- a/src/core/PaperScopeItem.js
+++ b/src/core/PaperScopeItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index e64ef2a7..00a40985 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/docs/global.js b/src/docs/global.js
index eda33ba7..400e8a40 100644
--- a/src/docs/global.js
+++ b/src/docs/global.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/dom/DomElement.js b/src/dom/DomElement.js
index 72e047f0..6b92c895 100644
--- a/src/dom/DomElement.js
+++ b/src/dom/DomElement.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/dom/DomEvent.js b/src/dom/DomEvent.js
index ca1e6cad..56ac214f 100644
--- a/src/dom/DomEvent.js
+++ b/src/dom/DomEvent.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/event/Event.js b/src/event/Event.js
index 94e9515f..297282e0 100644
--- a/src/event/Event.js
+++ b/src/event/Event.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/event/Key.js b/src/event/Key.js
index 36590d0b..be425b42 100644
--- a/src/event/Key.js
+++ b/src/event/Key.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/event/KeyEvent.js b/src/event/KeyEvent.js
index 8c7e0f70..b19539db 100644
--- a/src/event/KeyEvent.js
+++ b/src/event/KeyEvent.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/event/MouseEvent.js b/src/event/MouseEvent.js
index 485693d6..6700cba3 100644
--- a/src/event/MouseEvent.js
+++ b/src/event/MouseEvent.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/export.js b/src/export.js
index 8bdef8d8..dc4d5d9e 100644
--- a/src/export.js
+++ b/src/export.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/init.js b/src/init.js
index d0e399d7..55415286 100644
--- a/src/init.js
+++ b/src/init.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/ChangeFlag.js b/src/item/ChangeFlag.js
index 778bbfa4..4592c2c1 100644
--- a/src/item/ChangeFlag.js
+++ b/src/item/ChangeFlag.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Group.js b/src/item/Group.js
index ea3787de..fd5083c0 100644
--- a/src/item/Group.js
+++ b/src/item/Group.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/HitResult.js b/src/item/HitResult.js
index cc644373..ee804160 100644
--- a/src/item/HitResult.js
+++ b/src/item/HitResult.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Item.js b/src/item/Item.js
index 1c99c214..71448a25 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/ItemSelection.js b/src/item/ItemSelection.js
index 98acfd73..4b928e4c 100644
--- a/src/item/ItemSelection.js
+++ b/src/item/ItemSelection.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Layer.js b/src/item/Layer.js
index 5f3bf5ec..5229b1cb 100644
--- a/src/item/Layer.js
+++ b/src/item/Layer.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Project.js b/src/item/Project.js
index 810890a0..8d69d55e 100644
--- a/src/item/Project.js
+++ b/src/item/Project.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 39066a3f..29dce15f 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/Shape.js b/src/item/Shape.js
index 6a00ffa7..fed35b8e 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/SymbolDefinition.js b/src/item/SymbolDefinition.js
index 2cd43f34..3e907fb2 100644
--- a/src/item/SymbolDefinition.js
+++ b/src/item/SymbolDefinition.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 0d2beef2..437789f2 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/load.js b/src/load.js
index ff92efff..061ac532 100644
--- a/src/load.js
+++ b/src/load.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/net/Http.js b/src/net/Http.js
index a7b138e3..0e9b867f 100644
--- a/src/net/Http.js
+++ b/src/net/Http.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/node/canvas.js b/src/node/canvas.js
index 3f122a4b..1d12b0c6 100644
--- a/src/node/canvas.js
+++ b/src/node/canvas.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/node/extend.js b/src/node/extend.js
index e994d7b4..a950e4b3 100644
--- a/src/node/extend.js
+++ b/src/node/extend.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/node/self.js b/src/node/self.js
index 9232b5d5..8533cdd8 100644
--- a/src/node/self.js
+++ b/src/node/self.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/node/xml.js b/src/node/xml.js
index 04eaa168..74087246 100644
--- a/src/node/xml.js
+++ b/src/node/xml.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/options.js b/src/options.js
index 3285b843..5d7dc14d 100644
--- a/src/options.js
+++ b/src/options.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/paper.js b/src/paper.js
index 96c37775..fc00e683 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -2,7 +2,7 @@
  * Paper.js v*#=*__options.version - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
@@ -15,7 +15,7 @@
  *
  * Straps.js - Class inheritance library with support for bean-style accessors
  *
- * Copyright (c) 2006 - 2016 Juerg Lehni
+ * Copyright (c) 2006 - 2019 Juerg Lehni
  * http://scratchdisk.com/
  *
  * Distributed under the MIT license.
diff --git a/src/path/CompoundPath.js b/src/path/CompoundPath.js
index 5f6d0281..4643942b 100644
--- a/src/path/CompoundPath.js
+++ b/src/path/CompoundPath.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/Curve.js b/src/path/Curve.js
index 7587037e..26798499 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index a6e6c752..19b31dc9 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/Path.Constructors.js b/src/path/Path.Constructors.js
index 0664263e..ea92ee16 100644
--- a/src/path/Path.Constructors.js
+++ b/src/path/Path.Constructors.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/Path.js b/src/path/Path.js
index 513942cd..d9e631f7 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/PathFitter.js b/src/path/PathFitter.js
index 86c97dbd..27361e69 100644
--- a/src/path/PathFitter.js
+++ b/src/path/PathFitter.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/PathFlattener.js b/src/path/PathFlattener.js
index 10bf4605..2f7899d1 100644
--- a/src/path/PathFlattener.js
+++ b/src/path/PathFlattener.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 90f19bf5..018555aa 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index 41f6d736..e7ff2d17 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/Segment.js b/src/path/Segment.js
index 28cd5301..4fa11d0f 100644
--- a/src/path/Segment.js
+++ b/src/path/Segment.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/SegmentPoint.js b/src/path/SegmentPoint.js
index 4e2d22b5..a6bf3428 100644
--- a/src/path/SegmentPoint.js
+++ b/src/path/SegmentPoint.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/path/SegmentSelection.js b/src/path/SegmentSelection.js
index 429545cb..abe4af55 100644
--- a/src/path/SegmentSelection.js
+++ b/src/path/SegmentSelection.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/style/Color.js b/src/style/Color.js
index c4ff5fd4..2e1d4a70 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/style/Gradient.js b/src/style/Gradient.js
index 10f7a93b..512a835b 100644
--- a/src/style/Gradient.js
+++ b/src/style/Gradient.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/style/GradientStop.js b/src/style/GradientStop.js
index f3ef46ef..72367d11 100644
--- a/src/style/GradientStop.js
+++ b/src/style/GradientStop.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/style/Style.js b/src/style/Style.js
index a149c00d..5f868e82 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/svg/SvgElement.js b/src/svg/SvgElement.js
index 4dfa9d48..f345dc50 100644
--- a/src/svg/SvgElement.js
+++ b/src/svg/SvgElement.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index 8daf6bb6..5048bc2c 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 76053626..829d7b19 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/svg/SvgStyles.js b/src/svg/SvgStyles.js
index da1c54f0..9d8bab08 100644
--- a/src/svg/SvgStyles.js
+++ b/src/svg/SvgStyles.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/text/PointText.js b/src/text/PointText.js
index 3740da57..fabc566c 100644
--- a/src/text/PointText.js
+++ b/src/text/PointText.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/text/TextItem.js b/src/text/TextItem.js
index d35d59c6..11cc315d 100644
--- a/src/text/TextItem.js
+++ b/src/text/TextItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/tool/Tool.js b/src/tool/Tool.js
index 22f96800..69699f09 100644
--- a/src/tool/Tool.js
+++ b/src/tool/Tool.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/tool/ToolEvent.js b/src/tool/ToolEvent.js
index 136d0278..b9747459 100644
--- a/src/tool/ToolEvent.js
+++ b/src/tool/ToolEvent.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/util/Formatter.js b/src/util/Formatter.js
index 03c6dafd..58fded28 100644
--- a/src/util/Formatter.js
+++ b/src/util/Formatter.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/util/Numerical.js b/src/util/Numerical.js
index 796dbf4e..54d4c5db 100644
--- a/src/util/Numerical.js
+++ b/src/util/Numerical.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/util/UID.js b/src/util/UID.js
index 11f8e2d0..0c315f26 100644
--- a/src/util/UID.js
+++ b/src/util/UID.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index b783eeb0..ae804aad 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/src/view/View.js b/src/view/View.js
index 6172eb5e..fc16a67e 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/helpers.js b/test/helpers.js
index 98f402cc..72574077 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/load.js b/test/load.js
index 2b2796c4..0769f330 100644
--- a/test/load.js
+++ b/test/load.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Color.js b/test/tests/Color.js
index ade52127..d8af1967 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/CompoundPath.js b/test/tests/CompoundPath.js
index 9c807012..2bad91e4 100644
--- a/test/tests/CompoundPath.js
+++ b/test/tests/CompoundPath.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Curve.js b/test/tests/Curve.js
index 95dd948e..82ea945f 100644
--- a/test/tests/Curve.js
+++ b/test/tests/Curve.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/CurveLocation.js b/test/tests/CurveLocation.js
index e2687a08..816a7337 100644
--- a/test/tests/CurveLocation.js
+++ b/test/tests/CurveLocation.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Emitter.js b/test/tests/Emitter.js
index b3207da6..2bbfdc98 100644
--- a/test/tests/Emitter.js
+++ b/test/tests/Emitter.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 98c672ce..2326c100 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/HitResult.js b/test/tests/HitResult.js
index d7f913d5..e9926815 100644
--- a/test/tests/HitResult.js
+++ b/test/tests/HitResult.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Interactions.js b/test/tests/Interactions.js
index 7266f5c6..299d564b 100644
--- a/test/tests/Interactions.js
+++ b/test/tests/Interactions.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 79f6a396..28242f69 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Item_Bounds.js b/test/tests/Item_Bounds.js
index 0796331e..0bdc3532 100644
--- a/test/tests/Item_Bounds.js
+++ b/test/tests/Item_Bounds.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Item_Cloning.js b/test/tests/Item_Cloning.js
index 1ff197f8..723a2a20 100644
--- a/test/tests/Item_Cloning.js
+++ b/test/tests/Item_Cloning.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Item_Getting.js b/test/tests/Item_Getting.js
index 3dc248f4..d561572f 100644
--- a/test/tests/Item_Getting.js
+++ b/test/tests/Item_Getting.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Item_Order.js b/test/tests/Item_Order.js
index 02d4e60b..2d0adb2b 100644
--- a/test/tests/Item_Order.js
+++ b/test/tests/Item_Order.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/JSON.js b/test/tests/JSON.js
index 2bb5fe8a..f8744224 100644
--- a/test/tests/JSON.js
+++ b/test/tests/JSON.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Layer.js b/test/tests/Layer.js
index f13bd5de..2b73b52e 100644
--- a/test/tests/Layer.js
+++ b/test/tests/Layer.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Matrix.js b/test/tests/Matrix.js
index 5d3d48c2..ec499e4a 100644
--- a/test/tests/Matrix.js
+++ b/test/tests/Matrix.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Numerical.js b/test/tests/Numerical.js
index c6cb4843..4bf3040f 100644
--- a/test/tests/Numerical.js
+++ b/test/tests/Numerical.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Path.js b/test/tests/Path.js
index ad2c6135..4fce91d9 100644
--- a/test/tests/Path.js
+++ b/test/tests/Path.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/PathItem.js b/test/tests/PathItem.js
index ac969c4d..e92c4a1e 100644
--- a/test/tests/PathItem.js
+++ b/test/tests/PathItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/PathItem_Contains.js b/test/tests/PathItem_Contains.js
index f9ed0b1f..34787374 100644
--- a/test/tests/PathItem_Contains.js
+++ b/test/tests/PathItem_Contains.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index 64e00854..ded1a1b1 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Path_Constructors.js b/test/tests/Path_Constructors.js
index e5299b69..e4eaa33f 100644
--- a/test/tests/Path_Constructors.js
+++ b/test/tests/Path_Constructors.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index d30a13c7..6e69ec65 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Point.js b/test/tests/Point.js
index ddade38b..46a415d6 100644
--- a/test/tests/Point.js
+++ b/test/tests/Point.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Project.js b/test/tests/Project.js
index 9fd536f6..31da0956 100644
--- a/test/tests/Project.js
+++ b/test/tests/Project.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Raster.js b/test/tests/Raster.js
index b67b90e9..eb13e11a 100644
--- a/test/tests/Raster.js
+++ b/test/tests/Raster.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Rectangle.js b/test/tests/Rectangle.js
index 0f658a68..70de44ca 100644
--- a/test/tests/Rectangle.js
+++ b/test/tests/Rectangle.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Segment.js b/test/tests/Segment.js
index ca225bf3..29bb0434 100644
--- a/test/tests/Segment.js
+++ b/test/tests/Segment.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Shape.js b/test/tests/Shape.js
index 480bf143..3380e92f 100644
--- a/test/tests/Shape.js
+++ b/test/tests/Shape.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Size.js b/test/tests/Size.js
index 33c1194b..14f3ac61 100644
--- a/test/tests/Size.js
+++ b/test/tests/Size.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/Style.js b/test/tests/Style.js
index 25a12e0c..f930592b 100644
--- a/test/tests/Style.js
+++ b/test/tests/Style.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index feb389aa..e50225c2 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index 2ac5c7b2..a0c3e261 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/SymbolItem.js b/test/tests/SymbolItem.js
index 00ea5ec3..9e3ba191 100644
--- a/test/tests/SymbolItem.js
+++ b/test/tests/SymbolItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/TextItem.js b/test/tests/TextItem.js
index 5e76116c..d544dcc2 100644
--- a/test/tests/TextItem.js
+++ b/test/tests/TextItem.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/test/tests/load.js b/test/tests/load.js
index 97becd50..647e8e8c 100644
--- a/test/tests/load.js
+++ b/test/tests/load.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
diff --git a/travis/deploy-prebuilt.sh b/travis/deploy-prebuilt.sh
index 3a139901..4e786d91 100755
--- a/travis/deploy-prebuilt.sh
+++ b/travis/deploy-prebuilt.sh
@@ -3,7 +3,7 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
 # http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
diff --git a/travis/install-assets.sh b/travis/install-assets.sh
index 3286c638..8c1b9b8e 100755
--- a/travis/install-assets.sh
+++ b/travis/install-assets.sh
@@ -3,7 +3,7 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
 # http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
diff --git a/travis/setup-git.sh b/travis/setup-git.sh
index 77339166..52021b5f 100755
--- a/travis/setup-git.sh
+++ b/travis/setup-git.sh
@@ -3,7 +3,7 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
 # http://scratchdisk.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.

From 6fc1b122d61d85605b4b498557b58fb6ca19be56 Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Fri, 5 Oct 2018 19:31:27 +0900
Subject: [PATCH 047/181] Add stackoverflow for Questions

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 70ee71e5..97f720a1 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@ If you want to work with Paper.js, simply download the latest "stable" version
 from [http://paperjs.org/download/](http://paperjs.org/download/)
 
 - Website: <http://paperjs.org/>
+- Questions: <https://stackoverflow.com/questions/tagged/paperjs>
 - Discussion forum: <https://groups.google.com/group/paperjs>
 - Mainline source code: <https://github.com/paperjs/paper.js>
 - Twitter: [@paperjs](https://twitter.com/paperjs)

From fcfebdc43bd316f419eed33bf736436b70ba7f3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 11 Apr 2019 19:37:26 +0200
Subject: [PATCH 048/181] Include Raster.context accessor

---
 src/item/Raster.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index 29dce15f..0a8b81fa 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -18,6 +18,7 @@
  * @extends Item
  */
 var Raster = Item.extend(/** @lends Raster# */{
+}, /** @lends Raster# */{
     _class: 'Raster',
     _applyMatrix: false,
     _canApplyMatrix: false,
@@ -31,6 +32,9 @@ var Raster = Item.extend(/** @lends Raster# */{
     // Prioritize `crossOrigin` over `source`:
     _prioritize: ['crossOrigin'],
     _smoothing: true,
+    // Enforce creation of beans, as bean getters have hidden parameters.
+    // See  #getContext(modify) below.
+    beans: true,
 
     // TODO: Implement type, width, height.
     // TODO: Have SymbolItem & Raster inherit from a shared class?

From e436d44f146acbcb05cc1a52cf3d3b48a9506694 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 11 Apr 2019 19:37:49 +0200
Subject: [PATCH 049/181] Allow `new Raster(size)` constructor

---
 src/item/Raster.js | 34 ++++++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index 0a8b81fa..856e0ee6 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -81,22 +81,40 @@ var Raster = Item.extend(/** @lends Raster# */{
      * raster.scale(0.5);
      * raster.rotate(10);
      */
-    initialize: function Raster(object, position) {
+    initialize: function Raster(source, position) {
         // Support two forms of item initialization: Passing one object literal
         // describing all the different properties to be set, or an image
         // (object) and a point where it should be placed (point).
         // If _initialize can set properties through object literal, we're done.
         // Otherwise we need to check the type of object:
-        if (!this._initialize(object,
-                position !== undefined && Point.read(arguments, 1))) {
-            // object can be an image, canvas, URL or DOM-ID:
-            var image = typeof object === 'string'
-                    ? document.getElementById(object) : object;
+
+        // source can be an image, canvas, source URL or DOM-ID:
+        var image,
+            type = typeof source,
+            object = type === 'string'
+                ? document.getElementById(source)
+                : type  === 'object'
+                    ? source
+                    : null;
+        if (object && object !== Item.NO_INSERT) {
+            // #setImage() handles both canvas and image types.
+            if (object.getContent || object.naturalHeight != null) {
+                image = object;
+            } else if (object) {
+                // See if the arguments describe the raster size:
+                var size = Size.read(arguments);
+                if (!size.isZero()) {
+                    image = CanvasProvider.getCanvas(size);
+                }
+            }
+        }
+
+        if (!this._initialize(source,
+                position !== undefined && Point.read(arguments))) {
             if (image) {
-                // #setImage() handles both canvas and image types.
                 this.setImage(image);
             } else {
-                this.setSource(object);
+                this.setSource(source);
             }
         }
         if (!this._size) {

From ea91efe810a0a86ed27e13e94226e1da7597d1ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 11 Apr 2019 19:38:12 +0200
Subject: [PATCH 050/181] Add Raster.clear() to clear associated canvas

---
 src/item/Raster.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index 856e0ee6..b150504d 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -680,6 +680,14 @@ var Raster = Item.extend(/** @lends Raster# */{
         ctx.putImageData(imageData, point.x, point.y);
     },
 
+    /**
+     * Clears the image, if it is backed by a canvas.
+     */
+    clear: function() {
+        var size = this._size;
+        this.getContext().clearRect(0, 0, size.width + 1, size.height + 1);
+    },
+
     // DOCS: document Raster#createImageData
     /**
      * {@grouptitle Image Data}

From a7698318092fb0ae05a17fc6b570e5d0201ce43f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 11 Apr 2019 19:52:17 +0200
Subject: [PATCH 051/181] Update CHANGELOG for upcoming v0.12.1

---
 CHANGELOG.md | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 03c89576..05595d9c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,20 @@
 # Change Log
 
-## Prebuilt version
+## 0.12.1
+
+### Added
+
+- Add TypesSript definition, automatically generated from JSDoc comments
+  (#1612).
+- Support `new Raster(size)` constructor.
+- Expose `Raster#context` accessor.
+- Implement `Raster#clear()` method to clear associated canvas context.
 
 ### Fixed
 
-- Fix css color parse (#1629)
+- Fix parsing of CSS colors with spaces in parentheses (#1629).
+- Improve `Color.random()` documentation.
+- Fix `Tween#then()` documentation.
 
 ## `0.12.0`
 

From 330b7d0eb99a27d1f532b051228cfa9d757dcb3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 11 Apr 2019 20:01:31 +0200
Subject: [PATCH 052/181] Avoid clash with `--branch` argv in Node 10

---
 gulp/utils/options.js | 7 ++++---
 package.json          | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/gulp/utils/options.js b/gulp/utils/options.js
index 7fd7bd0c..e8b7c84d 100644
--- a/gulp/utils/options.js
+++ b/gulp/utils/options.js
@@ -24,9 +24,10 @@ options.date = git('log -1 --pretty=format:%ad');
 options.branch = git('rev-parse --abbrev-ref HEAD');
 
 // If a specific branch is requested, quit without errors if we don't match.
-if (argv.branch && argv.branch !== options.branch) {
-    console.log('Branch "' + options.branch + '" does not match "' +
-            argv.branch + '". There is nothing to do here.');
+var ensureBranch = argv['ensure-branch'];
+if (ensureBranch && ensureBranch !== options.branch) {
+    console.log('Branch "' + options.branch + '" does not match requested "' +
+            ensureBranch + '". There is nothing to do here.');
     process.exit(0);
 }
 
diff --git a/package.json b/package.json
index 5838bd08..5a136e7f 100644
--- a/package.json
+++ b/package.json
@@ -13,8 +13,8 @@
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
   "scripts": {
-    "precommit": "gulp jshint --branch develop",
-    "prepush": "gulp test --branch develop",
+    "precommit": "gulp jshint --ensure-branch develop",
+    "prepush": "gulp test --ensure-branch develop",
     "build": "gulp build",
     "dist": "gulp dist",
     "zip": "gulp zip",

From de36f39cbf52eba05bd0abfdcfbc72d0652a3d91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 15:31:09 +0200
Subject: [PATCH 053/181] Fix Raster#clear() to propagate content change

---
 src/item/Raster.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index b150504d..d1cc569a 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -33,7 +33,7 @@ var Raster = Item.extend(/** @lends Raster# */{
     _prioritize: ['crossOrigin'],
     _smoothing: true,
     // Enforce creation of beans, as bean getters have hidden parameters.
-    // See  #getContext(modify) below.
+    // See  #getContext(_change) below.
     beans: true,
 
     // TODO: Implement type, width, height.
@@ -354,13 +354,13 @@ var Raster = Item.extend(/** @lends Raster# */{
      * @bean
      * @type CanvasRenderingContext2D
      */
-    getContext: function(modify) {
+    getContext: function(_change) {
         if (!this._context)
             this._context = this.getCanvas().getContext('2d');
         // Support a hidden parameter that indicates if the context will be used
-        // to modify the Raster object. We can notify such changes ahead since
+        // to change the Raster object. We can notify such changes ahead since
         // they are only used afterwards for redrawing.
-        if (modify) {
+        if (_change) {
             // Also set _image to null since the Raster stops representing it.
             // NOTE: This should theoretically be in our own _changed() handler
             // for ChangeFlag.PIXELS, but since it's only happening in one place
@@ -685,7 +685,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      */
     clear: function() {
         var size = this._size;
-        this.getContext().clearRect(0, 0, size.width + 1, size.height + 1);
+        this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
     },
 
     // DOCS: document Raster#createImageData

From 9cafb6d55f0f404c614d7dcc3de2c1f1b0695353 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 17:35:21 +0200
Subject: [PATCH 054/181] =?UTF-8?q?Only=20set=20src=20attribute=20if=20it?=
 =?UTF-8?q?=E2=80=99s=20not=20empty?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

window.Image does not support clearing the attribute by setting it to null
---
 src/item/Raster.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index d1cc569a..e8873e13 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -408,7 +408,8 @@ var Raster = Item.extend(/** @lends Raster# */{
             crossOrigin = this._crossOrigin;
         if (crossOrigin)
             image.crossOrigin = crossOrigin;
-        image.src = src;
+        if (src)
+            image.src = src;
         this.setImage(image);
     },
 

From 022a4c9c81f38172050012fa9d204ec69598c45b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 17:35:42 +0200
Subject: [PATCH 055/181] Fix temporary test name

---
 test/tests/Item_Bounds.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/tests/Item_Bounds.js b/test/tests/Item_Bounds.js
index 0bdc3532..3e9417d9 100644
--- a/test/tests/Item_Bounds.js
+++ b/test/tests/Item_Bounds.js
@@ -722,7 +722,7 @@ test('path.strokeBounds with applyMatrix disabled', function() {
     testHitResult();
 });
 
-test('TEST', function() {
+test('path.strokeBounds with applyMatrix enabled', function() {
     var path = new Path.Rectangle({
         applyMatrix: false,
         point: [10, 10],

From 88c4275fa324d54b74dbfd9b11614930e238456a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 17:36:56 +0200
Subject: [PATCH 056/181] Keep code on 80 chars per line

---
 test/helpers.js | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/test/helpers.js b/test/helpers.js
index 72574077..724a15ea 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -201,10 +201,10 @@ var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
         });
     }
     resemble(imageData1)
-    .compareTo(imageData2)
-    .ignoreAntialiasing()
-    // When working with imageData, this call is synchronous:
-    .onComplete(function(data) { result = data; });
+        .compareTo(imageData2)
+        .ignoreAntialiasing()
+        // When working with imageData, this call is synchronous:
+        .onComplete(function(data) { result = data; });
     // Compare with tolerance in percentage...
     var fixed = tolerance < 1 ? ((1 / tolerance) + '').length - 1 : 0,
         identical = result ? 100 - result.misMatchPercentage : 0,
@@ -260,12 +260,12 @@ var comparePixels = function(actual, expected, message, options) {
     // bounds of both items before rasterizing.
     var resolution = options.resolution || 72,
         actualBounds = actual.strokeBounds,
-        expecedBounds = expected.strokeBounds,
+        expectedBounds = expected.strokeBounds,
         bounds = actualBounds.isEmpty()
-            ? expecedBounds
-            : expecedBounds.isEmpty()
+            ? expectedBounds
+            : expectedBounds.isEmpty()
                 ? actualBounds
-                : actualBounds.unite(expecedBounds);
+                : actualBounds.unite(expectedBounds);
     if (bounds.isEmpty()) {
         QUnit.equal('empty', 'empty', message);
         return;
@@ -288,10 +288,15 @@ var comparePixels = function(actual, expected, message, options) {
     } else {
         // Compare the two rasterized items.
         var detail = actual instanceof PathItem && expected instanceof PathItem
-            ? '\nExpected:\n' + expected.pathData + '\nActual:\n' + actual.pathData
+            ? '\nExpected:\n' + expected.pathData +
+                '\nActual:\n' + actual.pathData
             : '';
-        compareImageData(actualRaster.getImageData(),
-            expectedRaster.getImageData(), options.tolerance, detail);
+        compareImageData(
+            actualRaster.getImageData(),
+            expectedRaster.getImageData(),
+            options.tolerance,
+            detail
+        );
     }
 };
 
@@ -340,7 +345,8 @@ var compareItem = function(actual, expected, message, options, properties) {
  * @param {function} actualCallback the function producing the actual result
  * @param {number} tolerance between 0 and 1
  */
-var compareCanvas = function(width, height, expectedCallback, actualCallback, tolerance) {
+var compareCanvas = function(width, height, expectedCallback, actualCallback,
+        tolerance) {
     function getImageData(width, height, callback) {
         var canvas = document.createElement('canvas');
         canvas.width = width;
@@ -348,7 +354,8 @@ var compareCanvas = function(width, height, expectedCallback, actualCallback, to
         var project = new Project(canvas);
         callback();
         project.view.update();
-        var imageData = canvas.getContext('2d').getImageData(0, 0, width, height);
+        var context = canvas.getContext('2d');
+        var imageData = context.getImageData(0, 0, width, height);
         canvas.remove();
         project.remove();
         return imageData;

From 2cb55a839d776215c8f966ae01c677a394368661 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 18:13:22 +0200
Subject: [PATCH 057/181] Update dependencies

---
 package.json               | 112 +++++++++++++++++++++++--------------
 src/node/self.js           |  28 +++++++---
 test/tests/Path_Boolean.js |   3 +-
 3 files changed, 91 insertions(+), 52 deletions(-)

diff --git a/package.json b/package.json
index 5a136e7f..35d6ce77 100644
--- a/package.json
+++ b/package.json
@@ -9,12 +9,13 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
+  "contributors": [
+    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
+    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
+  ],
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
   "scripts": {
-    "precommit": "gulp jshint --ensure-branch develop",
-    "prepush": "gulp test --ensure-branch develop",
     "build": "gulp build",
     "dist": "gulp dist",
     "zip": "gulp zip",
@@ -23,46 +24,22 @@
     "jshint": "gulp jshint",
     "test": "gulp test"
   },
-  "files": ["AUTHORS.md", "CHANGELOG.md", "dist/", "examples/", "LICENSE.txt", "README.md"],
+  "files": [
+    "AUTHORS.md",
+    "CHANGELOG.md",
+    "dist/",
+    "examples/",
+    "LICENSE.txt",
+    "README.md"
+  ],
   "engines": {
     "node": ">=4.0.0"
   },
-  "devDependencies": {
-    "acorn": "~0.5.0",
-    "canvas": "^1.3.5",
-    "del": "^2.2.1",
-    "gulp": "^3.9.1",
-    "gulp-cached": "^1.1.0",
-    "gulp-git-streamed": "^2.8.1",
-    "gulp-jshint": "^2.0.0",
-    "gulp-json-editor": "^2.2.1",
-    "gulp-prepro": "^2.4.0",
-    "gulp-qunits": "^2.1.1",
-    "gulp-rename": "^1.2.2",
-    "gulp-shell": "^0.5.2",
-    "gulp-symlink": "^2.1.4",
-    "gulp-uglify": "^1.5.4",
-    "gulp-uncomment": "^0.3.0",
-    "gulp-util": "^3.0.7",
-    "gulp-webserver": "^0.9.1",
-    "gulp-whitespace": "^0.1.0",
-    "gulp-zip": "^3.2.0",
-    "husky": "^0.11.4",
-    "jsdom": "^9.4.0",
-    "jshint": "^2.9.2",
-    "jshint-summary": "^0.4.0",
-    "merge-stream": "^1.0.0",
-    "minimist": "^1.2.0",
-    "mustache": "^3.0.1",
-    "prepro": "^2.4.0",
-    "qunitjs": "^1.23.0",
-    "require-dir": "^0.3.0",
-    "resemblejs": "^2.2.1",
-    "run-sequence": "^1.2.2",
-    "source-map-support": "^0.4.0",
-    "stats.js": "0.16.0",
-    "straps": "^3.0.1",
-    "typescript": "^3.1.6"
+  "husky": {
+    "hooks": {
+      "pre-commit": "gulp jshint --ensure-branch develop",
+      "pre-push": "gulp test --ensure-branch develop"
+    }
   },
   "browser": {
     "canvas": false,
@@ -72,5 +49,58 @@
     "./dist/node/self.js": false,
     "./dist/node/extend.js": false
   },
-  "keywords": ["vector", "graphic", "graphics", "2d", "geometry", "bezier", "curve", "curves", "path", "paths", "canvas", "svg", "paper", "paper.js", "paperjs"]
+  "devDependencies": {
+    "acorn": "~0.5.0",
+    "canvas": "^2.4.1",
+    "del": "^4.1.0",
+    "gulp": "^3.9.1",
+    "gulp-cached": "^1.1.0",
+    "gulp-git-streamed": "^2.8.1",
+    "gulp-jshint": "^2.1.0",
+    "gulp-json-editor": "^2.5.2",
+    "gulp-prepro": "^2.4.0",
+    "gulp-qunits": "^2.1.2",
+    "gulp-rename": "^1.4.0",
+    "gulp-shell": "^0.7.0",
+    "gulp-symlink": "^2.1.4",
+    "gulp-uglify": "^1.5.4",
+    "gulp-uncomment": "^0.3.0",
+    "gulp-util": "^3.0.7",
+    "gulp-webserver": "^0.9.1",
+    "gulp-whitespace": "^0.1.0",
+    "gulp-zip": "^3.2.0",
+    "husky": "^2.3.0",
+    "jsdom": "^15.1.1",
+    "jshint": "^2.10.2",
+    "jshint-summary": "^0.4.0",
+    "merge-stream": "^2.0.0",
+    "minimist": "^1.2.0",
+    "mustache": "^3.0.1",
+    "prepro": "^2.4.0",
+    "qunitjs": "^1.23.0",
+    "require-dir": "^1.2.0",
+    "resemblejs": "^3.1.0",
+    "run-sequence": "^2.2.1",
+    "source-map-support": "^0.5.12",
+    "stats.js": "0.17.0",
+    "straps": "^3.0.1",
+    "typescript": "^3.1.6"
+  },
+  "keywords": [
+    "vector",
+    "graphic",
+    "graphics",
+    "2d",
+    "geometry",
+    "bezier",
+    "curve",
+    "curves",
+    "path",
+    "paths",
+    "canvas",
+    "svg",
+    "paper",
+    "paper.js",
+    "paperjs"
+  ]
 }
diff --git a/src/node/self.js b/src/node/self.js
index 8533cdd8..02a178ea 100644
--- a/src/node/self.js
+++ b/src/node/self.js
@@ -37,15 +37,25 @@ try {
 if (jsdom) {
     // Create our document and window objects through jsdom.
     /* global document:true, window:true */
-    var document = jsdom.jsdom('<html><body></body></html>', {
-        // Use the current working directory as the document's origin, so
-        // requests to local files work correctly with CORS.
-        url: 'file://' + process.cwd() + '/',
-        features: {
-            FetchExternalResources: ['img', 'script']
-        }
-    });
-    self = document.defaultView;
+    var html = '<html><body></body></html>',
+        options = {
+            // Use the current working directory as the document's origin, so
+            // requests to local files work correctly with CORS.
+            url: 'file://' + process.cwd() + '/',
+            // Old JSDOM:
+            features: {
+                FetchExternalResources: ['img', 'script']
+            },
+            // New JSDOM:
+            resources: 'usable'
+        };
+    if (jsdom.JSDOM) {
+        var dom = new jsdom.JSDOM(html, options);
+        self = dom.window;
+    } else {
+        var document = jsdom.jsdom(html, options);
+        self = document.defaultView;
+    }
     require('./canvas.js')(self, requireName);
     require('./xml.js')(self);
 } else {
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index ded1a1b1..c965ee89 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -219,7 +219,6 @@ test('#784', function() {
         'M265.13434,453.46566l-0.03434,0.03434c0,0 -49.1,-14.5 -36.6,-36.6c7.48073,-13.22593 39.10093,-1.6319 63.28843,9.81157l16.18604,-16.18604c-8.05354,-21.53223 -15.90287,-47.40397 -10.27447,-54.42553c9.77623,-12.51358 31.40373,30.40618 32.36674,32.33326l0.03326,-0.03326c0,0.1 65,49.8 65,65c0,15.2 -33.8,65 -65,65c-30.62393,0 -63.75273,-62.62185 -64.96566,-64.93434z');
 });
 
-
 test('#784#issuecomment-144653463', function() {
     var path1 = new Path({
         segments: [
@@ -1202,4 +1201,4 @@ test('#1513', function () {
     var path2  = PathItem.create('M200,100c55.22847,0 100,44.77153 100,100h-200c0,-55.22847 44.77153,-100 100,-100z');
     var result = 'M100,100h200v100c0,-55.22847 -44.77153,-100 -100,-100c-55.22847,0 -100,44.77153 -100,100z';
     compareBoolean(path1.subtract(path2), result);
-});
\ No newline at end of file
+});

From da137fa8e40c92d7a9f028c08b24f5fe6c2c3b1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 18:16:56 +0200
Subject: [PATCH 058/181] Use comparePixels() instead of compareCanvas()

---
 src/view/CanvasView.js |  4 ++++
 test/helpers.js        | 15 +++++++--------
 test/tests/Group.js    | 30 +++++++++++++-----------------
 3 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index ae804aad..85eecfb3 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -88,6 +88,10 @@ var CanvasView = View.extend(/** @lends CanvasView# */{
         }
     },
 
+    getContext: function() {
+        return this._context;
+    },
+
     /**
      * Converts the provide size in any of the units allowed in the browser to
      * pixels.
diff --git a/test/helpers.js b/test/helpers.js
index 724a15ea..b6b17392 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -345,25 +345,24 @@ var compareItem = function(actual, expected, message, options, properties) {
  * @param {function} actualCallback the function producing the actual result
  * @param {number} tolerance between 0 and 1
  */
-var compareCanvas = function(width, height, expectedCallback, actualCallback,
-        tolerance) {
+var compareCanvas = function(width, height, expected, actual, tolerance) {
     function getImageData(width, height, callback) {
         var canvas = document.createElement('canvas');
         canvas.width = width;
         canvas.height = height;
         var project = new Project(canvas);
+        var view = project.view;
         callback();
-        project.view.update();
-        var context = canvas.getContext('2d');
-        var imageData = context.getImageData(0, 0, width, height);
-        canvas.remove();
+        view.update();
+        var imageData = view.context.getImageData(0, 0, width, height);
         project.remove();
+        canvas.remove();
         return imageData;
     }
 
     compareImageData(
-        getImageData(width, height, expectedCallback),
-        getImageData(width, height, actualCallback),
+        getImageData(width, height, expected),
+        getImageData(width, height, actual),
         tolerance
     );
 
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 2326c100..52d7589d 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -137,21 +137,17 @@ test('group.addChildren()', function() {
 });
 
 test('group.setSelectedColor() with selected bound and position', function() {
-    compareCanvas(100, 100,
-        function() {
-            // working: set selected color first then add child
-            var group = new Group();
-            group.bounds.selected = true;
-            group.position.selected = true;
-            group.selectedColor = 'black';
-            group.addChild(new Path.Circle([50, 50], 40));
-        }, function() {
-            // failing: add child first then set selected color
-            var group = new Group();
-            group.bounds.selected = true;
-            group.position.selected = true;
-            group.addChild(new Path.Circle([50, 50], 40));
-            group.selectedColor = 'black';
-        }
-    );
+    // Working: Set selected color first then add child.
+    var group1 = new Group();
+    group1.bounds.selected = true;
+    group1.position.selected = true;
+    group1.selectedColor = 'black';
+    group1.addChild(new Path.Circle([50, 50], 40));
+    // Failing: Add child first then set selected color.
+    var group2 = new Group();
+    group2.bounds.selected = true;
+    group2.position.selected = true;
+    group2.addChild(new Path.Circle([50, 50], 40));
+    group2.selectedColor = 'black';
+    comparePixels(group1, group2);
 });

From af2415333b7916e50121f1608d439f1621bfc1c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 18:23:49 +0200
Subject: [PATCH 059/181] Test against stable node again
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Now that we’re on resemblejs 3
Relates to #1591
---
 .travis.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index c0903c5d..24c0b17f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +1,7 @@
 language: node_js
 # Follow https://github.com/nodejs/LTS to decide when to remove a version
 node_js:
-# Stable version is temporarily disabled due to a bug in resemblejs package with
-# node v11 (https://github.com/orgs/paperjs/teams/contributors/discussions/8).
-# - stable
+- stable
 - 10
 - 8
 # 6.13 and 6.14 causing unreasonable errors in SymbolDefinition.initialize.

From 767ce043bac216eb8a16c817c1d97046d0e01307 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 18:33:30 +0200
Subject: [PATCH 060/181] Remove node 6 support

---
 .travis.yml  | 5 -----
 package.json | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 24c0b17f..2c5d6f6c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,11 +4,6 @@ node_js:
 - stable
 - 10
 - 8
-# 6.13 and 6.14 causing unreasonable errors in SymbolDefinition.initialize.
-# https://travis-ci.org/paperjs/paper.js/jobs/434854796
-# To avoid these versions, we specify version to 6.12 as temporary solution.
-# See https://github.com/paperjs/paper.js/issues/1523
-- 6.12
 sudo: false
 env:
   matrix:
diff --git a/package.json b/package.json
index 35d6ce77..62191a19 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=8.0.0"
   },
   "husky": {
     "hooks": {

From bdc311e99f22e932ce862b723adf9187e36020a5 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Wed, 5 Jun 2019 19:58:22 +0200
Subject: [PATCH 061/181] Fix node tests crash with node latest versions

---
 .travis.yml            |  7 +++++--
 src/core/PaperScope.js |  8 +++++++-
 src/item/Raster.js     |  3 +++
 src/node/canvas.js     |  2 +-
 src/node/self.js       | 26 +++++++-------------------
 5 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 2c5d6f6c..239b6c99 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,10 @@
 language: node_js
 # Follow https://github.com/nodejs/LTS to decide when to remove a version
 node_js:
-- stable
+# Stable version is temporarily disabled due to a bug in resemblejs package with
+# node v12 (https://github.com/orgs/paperjs/teams/contributors/discussions/12).
+# - stable
+- 11
 - 10
 - 8
 sudo: false
@@ -40,4 +43,4 @@ script:
 - gulp minify
 - gulp test
 - gulp zip
-- '[ "${TRAVIS_BRANCH}" = "develop" ] && [ "${TRAVIS_NODE_VERSION}" = "stable" ] && travis/deploy-prebuilt.sh || true'
+- '[ "${TRAVIS_BRANCH}" = "develop" ] && [ "${TRAVIS_NODE_VERSION}" = "11" ] && travis/deploy-prebuilt.sh || true'
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index b6c2970d..02f7ca00 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -87,7 +87,7 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
             // here: { chrome: true, webkit: false }, Mozilla missing is the
             // only difference to jQuery.browser
             user.replace(
-                /(opera|chrome|safari|webkit|firefox|msie|trident|atom|node)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+                /(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
                 function(match, n, v1, v2, rv) {
                     // Do not set additional browsers once chrome is detected.
                     if (!agent.chrome) {
@@ -105,6 +105,12 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
                 delete agent.webkit;
             if (agent.atom)
                 delete agent.chrome;
+            // In node context, JSDOM user agent no longer include "node" word,
+            // it is now called "jsdom". So we need to replace it because
+            // `agent.node` is expected to be true in node context.
+            if (agent.jsdom) {
+                agent.node = true;
+            }
         }
     },
 
diff --git a/src/item/Raster.js b/src/item/Raster.js
index e8873e13..98562d33 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -408,6 +408,9 @@ var Raster = Item.extend(/** @lends Raster# */{
             crossOrigin = this._crossOrigin;
         if (crossOrigin)
             image.crossOrigin = crossOrigin;
+        // Prevent setting image source to `null`, as this isn't supported by browsers,
+        // and it would actually throw exceptions in JSDOM.
+        //TODO: Look into fixing this exception in JSDOM
         if (src)
             image.src = src;
         this.setImage(image);
diff --git a/src/node/canvas.js b/src/node/canvas.js
index 1d12b0c6..335f3873 100644
--- a/src/node/canvas.js
+++ b/src/node/canvas.js
@@ -18,7 +18,7 @@
 module.exports = function(self, requireName) {
     var Canvas;
     try {
-        Canvas = require('canvas');
+        Canvas = require('canvas').Canvas;
     } catch(error) {
         // Remove `self.window`, so we still have the global `self` reference,
         // but no `window` object:
diff --git a/src/node/self.js b/src/node/self.js
index 02a178ea..2ec77404 100644
--- a/src/node/self.js
+++ b/src/node/self.js
@@ -37,25 +37,13 @@ try {
 if (jsdom) {
     // Create our document and window objects through jsdom.
     /* global document:true, window:true */
-    var html = '<html><body></body></html>',
-        options = {
-            // Use the current working directory as the document's origin, so
-            // requests to local files work correctly with CORS.
-            url: 'file://' + process.cwd() + '/',
-            // Old JSDOM:
-            features: {
-                FetchExternalResources: ['img', 'script']
-            },
-            // New JSDOM:
-            resources: 'usable'
-        };
-    if (jsdom.JSDOM) {
-        var dom = new jsdom.JSDOM(html, options);
-        self = dom.window;
-    } else {
-        var document = jsdom.jsdom(html, options);
-        self = document.defaultView;
-    }
+    var document = new jsdom.JSDOM('<html><body></body></html>', {
+        // Use the current working directory as the document's origin, so
+        // requests to local files work correctly with CORS.
+        url: 'file://' + process.cwd() + '/',
+        resources: 'usable'
+    });
+    self = document.window;
     require('./canvas.js')(self, requireName);
     require('./xml.js')(self);
 } else {

From 5e64b78e4035a9a3811ed1af88a8ee733f3c8573 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 5 Jun 2019 20:03:11 +0200
Subject: [PATCH 062/181] Minor comment fixes

---
 src/core/PaperScope.js | 9 +++------
 src/item/Raster.js     | 6 +++---
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 02f7ca00..4624b58a 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -105,12 +105,9 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
                 delete agent.webkit;
             if (agent.atom)
                 delete agent.chrome;
-            // In node context, JSDOM user agent no longer include "node" word,
-            // it is now called "jsdom". So we need to replace it because
-            // `agent.node` is expected to be true in node context.
-            if (agent.jsdom) {
-                agent.node = true;
-            }
+            // In Node.js, the user agent set by JSDOM no longer includes `node`
+            // but `jsdom` instead. Preserve `agent.node`:
+            agent.node = agent.jsdom;
         }
     },
 
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 98562d33..6d784a58 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -408,9 +408,9 @@ var Raster = Item.extend(/** @lends Raster# */{
             crossOrigin = this._crossOrigin;
         if (crossOrigin)
             image.crossOrigin = crossOrigin;
-        // Prevent setting image source to `null`, as this isn't supported by browsers,
-        // and it would actually throw exceptions in JSDOM.
-        //TODO: Look into fixing this exception in JSDOM
+        // Prevent setting image source to `null`, as this isn't supported by
+        // browsers, and it would actually throw exceptions in JSDOM.
+        // TODO: Look into fixing this bug in JSDOM.
         if (src)
             image.src = src;
         this.setImage(image);

From c1d14bf472b86c1ef8bf9bebe700ec50f443d34e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 6 Jun 2019 00:04:28 +0200
Subject: [PATCH 063/181] Fix spelling mistakes

---
 src/docs/global.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/docs/global.js b/src/docs/global.js
index 400e8a40..6345b861 100644
--- a/src/docs/global.js
+++ b/src/docs/global.js
@@ -39,7 +39,7 @@
  *
  * The project for which the PaperScript is executed.
  *
- * Note that when working with mulitple projects, this does not necessarily
+ * Note that when working with multiple projects, this does not necessarily
  * reflect the currently active project. For this, use
  * {@link PaperScope#project} instead.
  *
@@ -57,7 +57,7 @@
 /**
  * The reference to the project's view.
  *
- * Note that when working with mulitple projects, this does not necessarily
+ * Note that when working with multiple projects, this does not necessarily
  * reflect the view of the currently active project. For this, use
  * {@link PaperScope#view} instead.
  *
@@ -69,7 +69,7 @@
  * The reference to the tool object which is automatically created when global
  * tool event handlers are defined.
  *
- * Note that when working with mulitple tools, this does not necessarily
+ * Note that when working with multiple tools, this does not necessarily
  * reflect the currently active tool. For this, use {@link PaperScope#tool}
  * instead.
  *

From bcfc0eb4136e47bb3df0473e161e89f63d1fc637 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 6 Jun 2019 00:13:07 +0200
Subject: [PATCH 064/181] Release version 0.12.1

---
 CHANGELOG.md                |    14 +-
 dist/paper-core.js          | 15281 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17025 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |  7310 +++++++++++++++
 gulp/tasks/publish.js       |     2 +-
 package.json                |    34 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 9 files changed, 39632 insertions(+), 40 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js
 create mode 100644 dist/paper.d.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 05595d9c..b4d47d00 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,11 +4,12 @@
 
 ### Added
 
-- Add TypesSript definition, automatically generated from JSDoc comments
+- Add TypesScript definition, automatically generated from JSDoc comments
   (#1612).
 - Support `new Raster(size)` constructor.
 - Expose `Raster#context` accessor.
 - Implement `Raster#clear()` method to clear associated canvas context.
+- Node.js: Add support for Node.js v11 and v12.
 
 ### Fixed
 
@@ -16,13 +17,18 @@
 - Improve `Color.random()` documentation.
 - Fix `Tween#then()` documentation.
 
+### Removed
+
+- Node.js: Remove support for Node.js v6.
+
 ## `0.12.0`
 
 ### News
 
-Another release, another new member on the team: Please welcome [@arnoson](https://github.com/arnoson), who has
-worked hard on the all new animation support, exposed through the `Tween` class
-and its various methods on the `Item` class, see below for details:
+Another release, another new member on the team: Please welcome
+[@arnoson](https://github.com/arnoson), who has worked hard on the all new
+animation support, exposed through the `Tween` class and its various methods on
+the `Item` class, see below for details:
 
 ### Added
 
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..4ea56b36
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15280 @@
+/*!
+ * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Thu Jun 6 00:04:28 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg))
+							arg.insert = false;
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = n === 'trident' ? 'msie' : n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+			agent.node = agent.jsdom;
+		}
+	},
+
+	version: "0.12.1",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty()) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function() {
+		var children = this._children;
+		return !children || !children.length;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish)
+			ctx.clip();
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(
+				matrix && matrix.appended(clipItem._matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+
+		var image,
+			type = typeof source,
+			object = type === 'string'
+				? document.getElementById(source)
+				: type  === 'object'
+					? source
+					: null;
+		if (object && object !== Item.NO_INSERT) {
+			if (object.getContent || object.naturalHeight != null) {
+				image = object;
+			} else if (object) {
+				var size = Size.read(arguments);
+				if (!size.isZero()) {
+					image = CanvasProvider.getCanvas(size);
+				}
+			}
+		}
+
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		var half = size / 2,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (!(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			var epsilon = 1e-7,
+				ext = abs(extent),
+				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+				inc = extent / count,
+				half = inc * Math.PI / 360,
+				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+				segments = [];
+			for (var i = 0; i <= count; i++) {
+				var pt = to,
+					out = null;
+				if (i < count) {
+					out = vector.rotate(90).multiply(z);
+					if (matrix) {
+						pt = matrix._transformPoint(vector);
+						out = matrix._transformPoint(vector.add(out))
+								.subtract(pt);
+					} else {
+						pt = center.add(vector);
+					}
+				}
+				if (!i) {
+					current.setHandleOut(out);
+				} else {
+					var _in = vector.rotate(-90).multiply(z);
+					if (matrix) {
+						_in = matrix._transformPoint(vector.add(_in))
+								.subtract(pt);
+					}
+					segments.push(new Segment(pt, _in, out));
+				}
+				vector = vector.rotate(inc);
+			}
+			this._add(segments);
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix);
+		if (normal1.getDirectedAngle(normal2) < 0) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner)
+				this._owner._changed(129);
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		var color = Color.read(arguments, 0, { clone: true });
+		if (color)
+			color._owner = this;
+		this._color = color;
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old && old._owner !== undefined) {
+							old._owner = undefined;
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							if (value._owner)
+								value = value.clone();
+							value._owner = owner;
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone)
+						value = value.clone();
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+						if (value && isColor)
+							value._owner = owner;
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			matrix = matrix._shiftless();
+			var point = matrix._inverseTransform(trans);
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+			trans = null;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.y)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent) {
+		var value = SvgElement.get(node, name),
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
+			destination = origin.add(
+					getValue(node, 'r', false, false, scaleToBounds), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		}
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..83489cfe
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17024 @@
+/*!
+ * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Thu Jun 6 00:04:28 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg))
+							arg.insert = false;
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = n === 'trident' ? 'msie' : n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+			agent.node = agent.jsdom;
+		}
+	},
+
+	version: "0.12.1",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty()) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function() {
+		var children = this._children;
+		return !children || !children.length;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish)
+			ctx.clip();
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(
+				matrix && matrix.appended(clipItem._matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+
+		var image,
+			type = typeof source,
+			object = type === 'string'
+				? document.getElementById(source)
+				: type  === 'object'
+					? source
+					: null;
+		if (object && object !== Item.NO_INSERT) {
+			if (object.getContent || object.naturalHeight != null) {
+				image = object;
+			} else if (object) {
+				var size = Size.read(arguments);
+				if (!size.isZero()) {
+					image = CanvasProvider.getCanvas(size);
+				}
+			}
+		}
+
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		var half = size / 2,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (!(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			var epsilon = 1e-7,
+				ext = abs(extent),
+				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+				inc = extent / count,
+				half = inc * Math.PI / 360,
+				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+				segments = [];
+			for (var i = 0; i <= count; i++) {
+				var pt = to,
+					out = null;
+				if (i < count) {
+					out = vector.rotate(90).multiply(z);
+					if (matrix) {
+						pt = matrix._transformPoint(vector);
+						out = matrix._transformPoint(vector.add(out))
+								.subtract(pt);
+					} else {
+						pt = center.add(vector);
+					}
+				}
+				if (!i) {
+					current.setHandleOut(out);
+				} else {
+					var _in = vector.rotate(-90).multiply(z);
+					if (matrix) {
+						_in = matrix._transformPoint(vector.add(_in))
+								.subtract(pt);
+					}
+					segments.push(new Segment(pt, _in, out));
+				}
+				vector = vector.rotate(inc);
+			}
+			this._add(segments);
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix);
+		if (normal1.getDirectedAngle(normal2) < 0) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner)
+				this._owner._changed(129);
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		var color = Color.read(arguments, 0, { clone: true });
+		if (color)
+			color._owner = this;
+		this._color = color;
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old && old._owner !== undefined) {
+							old._owner = undefined;
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							if (value._owner)
+								value = value.clone();
+							value._owner = owner;
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone)
+						value = value.clone();
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+						if (value && isColor)
+							value._owner = owner;
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			matrix = matrix._shiftless();
+			var point = matrix._inverseTransform(trans);
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+			trans = null;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.y)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent) {
+		var value = SvgElement.get(node, name),
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
+			destination = origin.add(
+					getValue(node, 'r', false, false, scaleToBounds), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		}
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (!node.prefix
+								&& (parentType === 'AssignmentExpression'
+									|| parentType === 'VariableDeclarator')) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, view: view, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
new file mode 100644
index 00000000..e05fac73
--- /dev/null
+++ b/dist/paper.d.ts
@@ -0,0 +1,7310 @@
+/*!
+ * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Thu Jun 6 00:04:28 2019 +0200
+ *
+ * This is an auto-generated type definition.
+ */
+
+declare module paper {
+    /** 
+     * The project for which the PaperScript is executed.
+     * 
+     * Note that when working with multiple projects, this does not necessarily
+     * reflect the currently active project. For this, use
+     * {@link PaperScope#project} instead.
+     */
+    let project: Project
+
+    /** 
+     * The list of all open projects within the current Paper.js context.
+     */
+    let projects: Project[]
+
+    /** 
+     * The reference to the project's view.
+     * 
+     * Note that when working with multiple projects, this does not necessarily
+     * reflect the view of the currently active project. For this, use
+     * {@link PaperScope#view} instead.
+     */
+    let view: View
+
+    /** 
+     * The reference to the tool object which is automatically created when global
+     * tool event handlers are defined.
+     * 
+     * Note that when working with multiple tools, this does not necessarily
+     * reflect the currently active tool. For this, use {@link PaperScope#tool}
+     * instead.
+     */
+    let tool: Tool
+
+    /** 
+     * The list of available tools.
+     */
+    let tools: Tool[]
+
+
+
+    /** 
+     * All properties and functions that expect color values in the form
+     * of instances of Color objects, also accept named colors and hex values as
+     * strings which are then converted to instances of
+     * {@link Color} internally.
+     */
+    class Color  {
+        /** 
+         * The type of the color as a string.
+         */
+        type: string
+
+        /** 
+         * The color components that define the color, including the alpha value
+         * if defined.
+         */
+        readonly components: number[]
+
+        /** 
+         * The color's alpha value as a number between `0` and `1`.
+         * All colors of the different subclasses support alpha values.
+         */
+        alpha: number
+
+        /** 
+         * The amount of red in the color as a value between `0` and `1`.
+         */
+        red: number
+
+        /** 
+         * The amount of green in the color as a value between `0` and `1`.
+         */
+        green: number
+
+        /** 
+         * The amount of blue in the color as a value between `0` and `1`.
+         */
+        blue: number
+
+        /** 
+         * The amount of gray in the color as a value between `0` and `1`.
+         */
+        gray: number
+
+        /** 
+         * The hue of the color as a value in degrees between `0` and `360`.
+         */
+        hue: number
+
+        /** 
+         * The saturation of the color as a value between `0` and `1`.
+         */
+        saturation: number
+
+        /** 
+         * The brightness of the color as a value between `0` and `1`.
+         */
+        brightness: number
+
+        /** 
+         * The lightness of the color as a value between `0` and `1`.
+         * 
+         * Note that all other components are shared with HSB.
+         */
+        lightness: number
+
+        /** 
+         * The gradient object describing the type of gradient and the stops.
+         */
+        gradient: Gradient
+
+        /** 
+         * The highlight point of the gradient.
+         */
+        highlight: Point
+
+
+        /** 
+         * Creates a RGB Color object.
+         * 
+         * @param red - the amount of red in the color as a value between
+         *     `0` and `1`
+         * @param green - the amount of green in the color as a value
+         *     between `0` and `1`
+         * @param blue - the amount of blue in the color as a value
+         *     between `0` and `1`
+         * @param alpha - the alpha of the color as a value between `0`
+         *     and `1`
+         */
+        constructor(red: number, green: number, blue: number, alpha?: number)
+
+        /** 
+         * Creates a Color object from a CSS string. All common CSS color string
+         * formats are supported:
+         * - Named colors (e.g. `'red'`, `'fuchsia'`, …)
+         * - Hex strings (`'#ffff00'`, `'#ff0'`, …)
+         * - RGB strings (`'rgb(255, 128, 0)'`, `'rgba(255, 128, 0, 0.5)'`, …)
+         * - HSL strings (`'hsl(180deg, 20%, 50%)'`,
+         *   `'hsla(3.14rad, 20%, 50%, 0.5)'`, …)
+         * 
+         * @param color - the color's CSS string representation
+         */
+        constructor(color: string)
+
+        /** 
+         * Creates a gradient Color object.
+         */
+        constructor(gradient: Gradient, origin: Point, destination: Point, highlight?: Point)
+
+        /** 
+         * Creates a gray Color object.
+         * 
+         * @param gray - the amount of gray in the color as a value
+         *     between `0` and `1`
+         * @param alpha - the alpha of the color as a value between `0`
+         *     and `1`
+         */
+        constructor(gray: number, alpha?: number)
+
+        /** 
+         * Creates a HSB, HSL or gradient Color object from the properties of
+         * the provided object:
+         * 
+         * @option hsb.hue {Number} the hue of the color as a value in degrees
+         *     between `0` and `360`
+         * @option hsb.saturation {Number} the saturation of the color as a
+         *     value between `0` and `1`
+         * @option hsb.brightness {Number} the brightness of the color as a
+         *     value between `0` and `1`
+         * @option hsb.alpha {Number} the alpha of the color as a value between
+         *     `0` and `1`
+         * @option hsl.hue {Number} the hue of the color as a value in degrees
+         *     between `0` and `360`
+         * @option hsl.saturation {Number} the saturation of the color as a
+         *     value between `0` and `1`
+         * @option hsl.lightness {Number} the lightness of the color as a value
+         *     between `0` and `1`<br>
+         * @option hsl.alpha {Number} the alpha of the color as a value between
+         *     `0` and `1`
+         * @option gradient.gradient {Gradient} the gradient object that
+         *     describes the color stops and type of gradient to be used
+         * @option gradient.origin {Point} the origin point of the gradient
+         * @option gradient.destination {Point} the destination point of the
+         *     gradient
+         * @option gradient.stops {GradientStop[]} the gradient stops describing
+         *     the gradient, as an alternative to providing a gradient object
+         * @option gradient.radial {Boolean} controls whether the gradient is
+         *     radial, as an alternative to providing a gradient object
+         * 
+         * @param object - an object describing the components and
+         * properties of the color
+         */
+        constructor(object: object)
+
+        /** 
+         * Sets the color to the passed values. Note that any sequence of
+         * parameters that is supported by the various {@link Color}
+         * constructors also work for calls of `set()`.
+         */
+        set(...value: any[]): Color
+
+        /** 
+         * Converts the color to another type.
+         * 
+         * @param type - the color type to convert to. Possible values:
+         * {@values 'rgb', 'gray', 'hsb', 'hsl'}
+         * 
+         * @return the converted color as a new instance
+         */
+        convert(type: string): Color
+
+        /** 
+         * Checks if the color has an alpha value.
+         * 
+         * @return true if the color has an alpha value
+         */
+        hasAlpha(): boolean
+
+        /** 
+         * Checks if the component color values of the color are the
+         * same as those of the supplied one.
+         * 
+         * @param color - the color to compare with
+         * 
+         * @return true if the colors are the same
+         */
+        equals(color: Color): boolean
+
+        /** 
+         * @return a copy of the color object
+         */
+        clone(): Color
+
+        /** 
+         * @return a string representation of the color
+         */
+        toString(): string
+
+        /** 
+         * Returns the division of the supplied color to the color as a new
+         * color.
+         * The object itself is not modified!
+         * 
+         * @param color - the color to divide
+         * 
+         * @return the division of the two colors as a new color
+         */
+        divide(color: Color): Color
+
+        /** 
+         * Transform the gradient color by the specified matrix.
+         * 
+         * @param matrix - the matrix to transform the gradient color by
+         */
+        transform(matrix: Matrix): void
+
+        /** 
+         * Returns a color object with random {@link #red}, {@link #green}
+         * and {@link #blue} values between `0` and `1`.
+         * 
+         * @return the newly created color object
+         */
+        static random(): Color
+
+        /** 
+         * Returns the addition of the supplied value to both coordinates of
+         * the color as a new color.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to add
+         * 
+         * @return the addition of the color and the value as a new
+         * color
+         */
+        add(number: number): Color
+
+        /** 
+         * Returns the addition of the supplied color to the color as a new
+         * color.
+         * The object itself is not modified!
+         * 
+         * @param color - the color to add
+         * 
+         * @return the addition of the two colors as a new color
+         */
+        add(color: Color): Color
+
+        /** 
+         * Returns the subtraction of the supplied value to both coordinates of
+         * the color as a new color.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to subtract
+         * 
+         * @return the subtraction of the color and the value as a new
+         * color
+         */
+        subtract(number: number): Color
+
+        /** 
+         * Returns the subtraction of the supplied color to the color as a new
+         * color.
+         * The object itself is not modified!
+         * 
+         * @param color - the color to subtract
+         * 
+         * @return the subtraction of the two colors as a new color
+         */
+        subtract(color: Color): Color
+
+        /** 
+         * Returns the multiplication of the supplied value to both coordinates
+         * of the color as a new color.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to multiply
+         * 
+         * @return the multiplication of the color and the value as a
+         * new color
+         */
+        multiply(number: number): Color
+
+        /** 
+         * Returns the multiplication of the supplied color to the color as a
+         * new color.
+         * The object itself is not modified!
+         * 
+         * @param color - the color to multiply
+         * 
+         * @return the multiplication of the two colors as a new color
+         */
+        multiply(color: Color): Color
+
+        /** 
+         * Returns the division of the supplied value to both coordinates of
+         * the color as a new color.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to divide
+         * 
+         * @return the division of the color and the value as a new
+         * color
+         */
+        divide(number: number): Color
+
+        /** 
+         * Returns the color as a CSS string.
+         * 
+         * @param hex - whether to return the color in hexadecimal
+         * representation or as a CSS RGB / RGBA string.
+         * 
+         * @return a CSS string representation of the color
+         */
+        toCSS(hex: boolean): string
+
+    }
+
+    /** 
+     * A compound path is a complex path that is made up of one or more
+     * simple sub-paths. It can have the `nonzero` fill rule, or the `evenodd` rule
+     * applied. Both rules use mathematical equations to determine if any region is
+     * outside or inside the final shape. The `evenodd` rule is more predictable:
+     * Every other region within a such a compound path is a hole, regardless of
+     * path direction.
+     * 
+     * All the paths in a compound path take on the style of the compound path and
+     * can be accessed through its {@link Item#children} list.
+     */
+    class CompoundPath extends PathItem {
+        /** 
+         * Specifies whether the compound-path is fully closed, meaning all its
+         * contained sub-paths are closed path.
+         * 
+         * @see Path#closed
+         */
+        closed: boolean
+
+        /** 
+         * The first Segment contained within the compound-path, a short-cut to
+         * calling {@link Path#firstSegment} on {@link Item#firstChild}.
+         */
+        readonly firstSegment: Segment
+
+        /** 
+         * The last Segment contained within the compound-path, a short-cut to
+         * calling {@link Path#lastSegment} on {@link Item#lastChild}.
+         */
+        readonly lastSegment: Segment
+
+        /** 
+         * All the curves contained within the compound-path, from all its child
+         * {@link Path} items.
+         */
+        readonly curves: Curve[]
+
+        /** 
+         * The first Curve contained within the compound-path, a short-cut to
+         * calling {@link Path#firstCurve} on {@link Item#firstChild}.
+         */
+        readonly firstCurve: Curve
+
+        /** 
+         * The last Curve contained within the compound-path, a short-cut to
+         * calling {@link Path#lastCurve} on {@link Item#lastChild}.
+         */
+        readonly lastCurve: Curve
+
+        /** 
+         * The area that the compound-path's geometry is covering, calculated by
+         * getting the {@link Path#area} of each sub-path and it adding up.
+         * Note that self-intersecting paths and sub-paths of different orientation
+         * can result in areas that cancel each other out.
+         */
+        readonly area: number
+
+        /** 
+         * The total length of all sub-paths in this compound-path, calculated by
+         * getting the {@link Path#length} of each sub-path and it adding up.
+         */
+        readonly length: number
+
+
+        /** 
+         * Creates a new compound path item from SVG path-data and places it at the
+         * top of the active layer.
+         * 
+         * @param pathData - the SVG path-data that describes the geometry
+         * of this path
+         */
+        constructor(pathData: string)
+
+        /** 
+         * Creates a new compound path item from an object description and places it
+         * at the top of the active layer.
+         * 
+         * @param object - an object containing properties to be set on the
+         *     path
+         */
+        constructor(object: object)
+
+    }
+
+    /** 
+     * The Curve object represents the parts of a path that are connected by
+     * two following {@link Segment} objects. The curves of a path can be accessed
+     * through its {@link Path#curves} array.
+     * 
+     * While a segment describe the anchor point and its incoming and outgoing
+     * handles, a Curve object describes the curve passing between two such
+     * segments. Curves and segments represent two different ways of looking at the
+     * same thing, but focusing on different aspects. Curves for example offer many
+     * convenient ways to work with parts of the path, finding lengths, positions or
+     * tangents at given offsets.
+     */
+    class Curve  {
+        /** 
+         * The first anchor point of the curve.
+         */
+        point1: Point
+
+        /** 
+         * The second anchor point of the curve.
+         */
+        point2: Point
+
+        /** 
+         * The handle point that describes the tangent in the first anchor point.
+         */
+        handle1: Point
+
+        /** 
+         * The handle point that describes the tangent in the second anchor point.
+         */
+        handle2: Point
+
+        /** 
+         * The first segment of the curve.
+         */
+        readonly segment1: Segment
+
+        /** 
+         * The second segment of the curve.
+         */
+        readonly segment2: Segment
+
+        /** 
+         * The path that the curve belongs to.
+         */
+        readonly path: Path
+
+        /** 
+         * The index of the curve in the {@link Path#curves} array.
+         */
+        readonly index: number
+
+        /** 
+         * The next curve in the {@link Path#curves} array that the curve
+         * belongs to.
+         */
+        readonly next: Curve
+
+        /** 
+         * The previous curve in the {@link Path#curves} array that the curve
+         * belongs to.
+         */
+        readonly previous: Curve
+
+        /** 
+         * Specifies whether the points and handles of the curve are selected.
+         */
+        selected: boolean
+
+        /** 
+         * An array of 8 float values, describing this curve's geometry in four
+         * absolute x/y pairs (point1, handle1, handle2, point2). This format is
+         * used internally for efficient processing of curve geometries, e.g. when
+         * calculating intersections or bounds.
+         * 
+         * Note that the handles are converted to absolute coordinates.
+         */
+        readonly values: number[]
+
+        /** 
+         * An array of 4 point objects, describing this curve's geometry in absolute
+         * coordinates (point1, handle1, handle2, point2).
+         * 
+         * Note that the handles are converted to absolute coordinates.
+         */
+        readonly points: Point[]
+
+        /** 
+         * The approximated length of the curve.
+         */
+        readonly length: number
+
+        /** 
+         * The area that the curve's geometry is covering.
+         */
+        readonly area: number
+
+        /** 
+         * The bounding rectangle of the curve excluding stroke width.
+         */
+        bounds: Rectangle
+
+        /** 
+         * The bounding rectangle of the curve including stroke width.
+         */
+        strokeBounds: Rectangle
+
+        /** 
+         * The bounding rectangle of the curve including handles.
+         */
+        handleBounds: Rectangle
+
+
+        /** 
+         * Creates a new curve object.
+         */
+        constructor(segment1: Segment, segment2: Segment)
+
+        /** 
+         * Creates a new curve object.
+         */
+        constructor(point1: Point, handle1: Point, handle2: Point, point2: Point)
+
+        /** 
+         * Returns a copy of the curve.
+         */
+        clone(): Curve
+
+        /** 
+         * @return a string representation of the curve
+         */
+        toString(): string
+
+        /** 
+         * Determines the type of cubic Bézier curve via discriminant
+         * classification, as well as the curve-time parameters of the associated
+         * points of inflection, loops, cusps, etc.
+         * 
+         * @return the curve classification information as an object, see
+         *     options
+         */
+        classify(): object
+
+        /** 
+         * Removes the curve from the path that it belongs to, by removing its
+         * second segment and merging its handle with the first segment.
+         * 
+         * @return true if the curve was removed
+         */
+        remove(): boolean
+
+        /** 
+         * Checks if the this is the first curve in the {@link Path#curves} array.
+         * 
+         * @return true if this is the first curve
+         */
+        isFirst(): boolean
+
+        /** 
+         * Checks if the this is the last curve in the {@link Path#curves} array.
+         * 
+         * @return true if this is the last curve
+         */
+        isLast(): boolean
+
+        /** 
+         * Creates a new curve as a sub-curve from this curve, its range defined by
+         * the given curve-time parameters. If `from` is larger than `to`, then
+         * the resulting curve will have its direction reversed.
+         * 
+         * @param from - the curve-time parameter at which the sub-curve
+         * starts
+         * @param to - the curve-time parameter at which the sub-curve
+         * ends
+         * 
+         * @return the newly create sub-curve
+         */
+        getPart(from: number, to: number): Curve
+
+        /** 
+         * Divides the curve into two curves at the given offset or location. The
+         * curve itself is modified and becomes the first part, the second part is
+         * returned as a new curve. If the curve belongs to a path item, a new
+         * segment is inserted into the path at the given location, and the second
+         * part becomes a part of the path as well.
+         * 
+         * @see #divideAtTime(time)
+         * 
+         * @param location - the offset or location on the
+         *     curve at which to divide
+         * 
+         * @return the second part of the divided curve if the location is
+         *     valid, {code null} otherwise
+         */
+        divideAt(location: number | CurveLocation): Curve
+
+        /** 
+         * Divides the curve into two curves at the given curve-time parameter. The
+         * curve itself is modified and becomes the first part, the second part is
+         * returned as a new curve. If the modified curve belongs to a path item,
+         * the second part is also added to the path.
+         * 
+         * @see #divideAt(offset)
+         * 
+         * @param time - the curve-time parameter on the curve at which to
+         *     divide
+         * 
+         * @return the second part of the divided curve, if the offset is
+         *     within the valid range, {code null} otherwise.
+         */
+        divideAtTime(time: number): Curve
+
+        /** 
+         * Splits the path this curve belongs to at the given offset. After
+         * splitting, the path will be open. If the path was open already, splitting
+         * will result in two paths.
+         * 
+         * @see Path#splitAt(offset)
+         * 
+         * @param location - the offset or location on the
+         *     curve at which to split
+         * 
+         * @return the newly created path after splitting, if any
+         */
+        splitAt(location: number | CurveLocation): Path
+
+        /** 
+         * Splits the path this curve belongs to at the given offset. After
+         * splitting, the path will be open. If the path was open already, splitting
+         * will result in two paths.
+         * 
+         * @see Path#splitAt(offset)
+         * 
+         * @param time - the curve-time parameter on the curve at which to
+         *     split
+         * 
+         * @return the newly created path after splitting, if any
+         */
+        splitAtTime(time: number): Path
+
+        /** 
+         * Returns a reversed version of the curve, without modifying the curve
+         * itself.
+         * 
+         * @return a reversed version of the curve
+         */
+        reversed(): Curve
+
+        /** 
+         * Clears the curve's handles by setting their coordinates to zero,
+         * turning the curve into a straight line.
+         */
+        clearHandles(): void
+
+        /** 
+         * Checks if this curve has any curve handles set.
+         * 
+         * @see Curve#handle1
+         * @see Curve#handle2
+         * @see Segment#hasHandles()
+         * @see Path#hasHandles()
+         * 
+         * @return true if the curve has handles set
+         */
+        hasHandles(): boolean
+
+        /** 
+         * Checks if this curve has any length.
+         * 
+         * @param epsilon - the epsilon against which to compare the
+         *     curve's length
+         * 
+         * @return true if the curve is longer than the given epsilon
+         */
+        hasLength(epsilon?: number): boolean
+
+        /** 
+         * Checks if this curve appears as a straight line. This can mean that
+         * it has no handles defined, or that the handles run collinear with the
+         * line that connects the curve's start and end point, not falling
+         * outside of the line.
+         * 
+         * @return true if the curve is straight
+         */
+        isStraight(): boolean
+
+        /** 
+         * Checks if this curve is parametrically linear, meaning that it is
+         * straight and its handles are positioned at 1/3 and 2/3 of the total
+         * length of the curve.
+         * 
+         * @return true if the curve is parametrically linear
+         */
+        isLinear(): boolean
+
+        /** 
+         * Checks if the the two curves describe straight lines that are
+         * collinear, meaning they run in parallel.
+         * 
+         * @param curve - the other curve to check against
+         * 
+         * @return true if the two lines are collinear
+         */
+        isCollinear(curve: Curve): boolean
+
+        /** 
+         * Checks if the curve is a straight horizontal line.
+         * 
+         * @return true if the line is horizontal
+         */
+        isHorizontal(): boolean
+
+        /** 
+         * Checks if the curve is a straight vertical line.
+         * 
+         * @return true if the line is vertical
+         */
+        isVertical(): boolean
+
+        /** 
+         * Returns all intersections between two {@link Curve} objects as an
+         * array of {@link CurveLocation} objects.
+         * 
+         * @param curve - the other curve to find the intersections with
+         *     (if the curve itself or `null` is passed, the self intersection
+         *     of the curve is returned, if it exists)
+         * 
+         * @return the locations of all intersections between
+         *     the curves
+         */
+        getIntersections(curve: Curve): CurveLocation[]
+
+        /** 
+         * Calculates the curve location at the specified curve-time parameter on
+         * the curve.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the curve location at the specified the location
+         */
+        getLocationAtTime(time: number): CurveLocation
+
+        /** 
+         * Calculates the curve-time parameter of the specified offset on the path,
+         * relative to the provided start parameter. If offset is a negative value,
+         * the parameter is searched to the left of the start parameter. If no start
+         * parameter is provided, a default of `0` for positive values of `offset`
+         * and `1` for negative values of `offset`.
+         * 
+         * @param offset - the offset at which to find the curve-time, in
+         *     curve length units
+         * @param start - the curve-time in relation to which the offset is
+         *     determined
+         * 
+         * @return the curve-time parameter at the specified location
+         */
+        getTimeAt(offset: number, start?: number): number
+
+        /** 
+         * Calculates the curve-time parameters where the curve is tangential to
+         * provided tangent. Note that tangents at the start or end are included.
+         * 
+         * @param tangent - the tangent to which the curve must be tangential
+         * 
+         * @return at most two curve-time parameters, where the curve is
+         * tangential to the given tangent
+         */
+        getTimesWithTangent(tangent: Point): number[]
+
+        /** 
+         * Calculates the curve offset at the specified curve-time parameter on
+         * the curve.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the curve offset at the specified the location
+         */
+        getOffsetAtTime(time: number): number
+
+        /** 
+         * Returns the curve location of the specified point if it lies on the
+         * curve, `null` otherwise.
+         * 
+         * @param point - the point on the curve
+         * 
+         * @return the curve location of the specified point
+         */
+        getLocationOf(point: Point): CurveLocation
+
+        /** 
+         * Returns the length of the path from its beginning up to up to the
+         * specified point if it lies on the path, `null` otherwise.
+         * 
+         * @param point - the point on the path
+         * 
+         * @return the length of the path up to the specified point
+         */
+        getOffsetOf(point: Point): number
+
+        /** 
+         * Returns the curve-time parameter of the specified point if it lies on the
+         * curve, `null` otherwise.
+         * Note that if there is more than one possible solution in a
+         * self-intersecting curve, the first found result is returned.
+         * 
+         * @param point - the point on the curve
+         * 
+         * @return the curve-time parameter of the specified point
+         */
+        getTimeOf(point: Point): number
+
+        /** 
+         * Returns the nearest location on the curve to the specified point.
+         * 
+         * @param point - the point for which we search the nearest location
+         * 
+         * @return the location on the curve that's the closest to
+         * the specified point
+         */
+        getNearestLocation(point: Point): CurveLocation
+
+        /** 
+         * Returns the nearest point on the curve to the specified point.
+         * 
+         * @param point - the point for which we search the nearest point
+         * 
+         * @return the point on the curve that's the closest to the
+         * specified point
+         */
+        getNearestPoint(point: Point): Point
+
+        /** 
+         * Calculates the point on the curve at the given location.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the point on the curve at the given location
+         */
+        getPointAt(location: number | CurveLocation): Point
+
+        /** 
+         * Calculates the normalized tangent vector of the curve at the given
+         * location.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the normalized tangent of the curve at the given location
+         */
+        getTangentAt(location: number | CurveLocation): Point
+
+        /** 
+         * Calculates the normal vector of the curve at the given location.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the normal of the curve at the given location
+         */
+        getNormalAt(location: number | CurveLocation): Point
+
+        /** 
+         * Calculates the weighted tangent vector of the curve at the given
+         * location, its length reflecting the curve velocity at that location.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the weighted tangent of the curve at the given location
+         */
+        getWeightedTangentAt(location: number | CurveLocation): Point
+
+        /** 
+         * Calculates the weighted normal vector of the curve at the given location,
+         * its length reflecting the curve velocity at that location.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the weighted normal of the curve at the given location
+         */
+        getWeightedNormalAt(location: number | CurveLocation): Point
+
+        /** 
+         * Calculates the curvature of the curve at the given location. Curvatures
+         * indicate how sharply a curve changes direction. A straight line has zero
+         * curvature, where as a circle has a constant curvature. The curve's radius
+         * at the given location is the reciprocal value of its curvature.
+         * 
+         * @param location - the offset or location on the
+         *     curve
+         * 
+         * @return the curvature of the curve at the given location
+         */
+        getCurvatureAt(location: number | CurveLocation): number
+
+        /** 
+         * Calculates the point on the curve at the given location.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the point on the curve at the given location
+         */
+        getPointAtTime(time: number): Point
+
+        /** 
+         * Calculates the normalized tangent vector of the curve at the given
+         * location.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the normalized tangent of the curve at the given location
+         */
+        getTangentAtTime(time: number): Point
+
+        /** 
+         * Calculates the normal vector of the curve at the given location.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the normal of the curve at the given location
+         */
+        getNormalAtTime(time: number): Point
+
+        /** 
+         * Calculates the weighted tangent vector of the curve at the given
+         * location, its length reflecting the curve velocity at that location.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the weighted tangent of the curve at the given location
+         */
+        getWeightedTangentAtTime(time: number): Point
+
+        /** 
+         * Calculates the weighted normal vector of the curve at the given location,
+         * its length reflecting the curve velocity at that location.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the weighted normal of the curve at the given location
+         */
+        getWeightedNormalAtTime(time: number): Point
+
+        /** 
+         * Calculates the curvature of the curve at the given location. Curvatures
+         * indicate how sharply a curve changes direction. A straight line has zero
+         * curvature, where as a circle has a constant curvature. The curve's radius
+         * at the given location is the reciprocal value of its curvature.
+         * 
+         * @param time - the curve-time parameter on the curve
+         * 
+         * @return the curvature of the curve at the given location
+         */
+        getCurvatureAtTime(time: number): number
+
+        /** 
+         * Calculates the curve location at the specified offset on the curve.
+         * 
+         * @param offset - the offset on the curve
+         * 
+         * @return the curve location at the specified the offset
+         */
+        getLocationAt(offset: number): CurveLocation
+
+    }
+
+    /** 
+     * CurveLocation objects describe a location on {@link Curve} objects, as
+     *     defined by the curve-time {@link #time}, a value between `0` (beginning
+     *     of the curve) and `1` (end of the curve). If the curve is part of a
+     *     {@link Path} item, its {@link #index} inside the {@link Path#curves}
+     *     array is also provided.
+     * 
+     * The class is in use in many places, such as
+     * {@link Path#getLocationAt},
+     * {@link Path#getLocationOf},
+     * {@link PathItem#getNearestLocation},
+     * {@link PathItem#getIntersections},
+     * etc.
+     */
+    class CurveLocation  {
+        /** 
+         * The segment of the curve which is closer to the described location.
+         */
+        readonly segment: Segment
+
+        /** 
+         * The curve that this location belongs to.
+         */
+        readonly curve: Curve
+
+        /** 
+         * The path that this locations is situated on.
+         */
+        readonly path: Path
+
+        /** 
+         * The index of the {@link #curve} within the {@link Path#curves} list, if
+         * it is part of a {@link Path} item.
+         */
+        readonly index: number
+
+        /** 
+         * The curve-time parameter, as used by various bezier curve calculations.
+         * It is value between `0` (beginning of the curve) and `1` (end of the
+         * curve).
+         */
+        readonly time: number
+
+        /** 
+         * The point which is defined by the {@link #curve} and
+         * {@link #time}.
+         */
+        readonly point: Point
+
+        /** 
+         * The length of the path from its beginning up to the location described
+         * by this object. If the curve is not part of a path, then the length
+         * within the curve is returned instead.
+         */
+        readonly offset: number
+
+        /** 
+         * The length of the curve from its beginning up to the location described
+         * by this object.
+         */
+        readonly curveOffset: number
+
+        /** 
+         * The curve location on the intersecting curve, if this location is the
+         * result of a call to {@link PathItem#getIntersections} /
+         * {@link Curve#getIntersections}.
+         */
+        readonly intersection: CurveLocation
+
+        /** 
+         * The tangential vector to the {@link #curve} at the given location.
+         */
+        readonly tangent: Point
+
+        /** 
+         * The normal vector to the {@link #curve} at the given location.
+         */
+        readonly normal: Point
+
+        /** 
+         * The curvature of the {@link #curve} at the given location.
+         */
+        readonly curvature: number
+
+        /** 
+         * The distance from the queried point to the returned location.
+         * 
+         * @see Curve#getNearestLocation(point)
+         * @see PathItem#getNearestLocation(point)
+         */
+        readonly distance: number
+
+
+        /** 
+         * Creates a new CurveLocation object.
+         */
+        constructor(curve: Curve, time: number, point?: Point)
+
+        /** 
+         * Checks whether tow CurveLocation objects are describing the same location
+         * on a path, by applying the same tolerances as elsewhere when dealing with
+         * curve-time parameters.
+         * 
+         * @return true if the locations are equal
+         */
+        equals(location: CurveLocation): boolean
+
+        /** 
+         * @return a string representation of the curve location
+         */
+        toString(): string
+
+        /** 
+         * Checks if the location is an intersection with another curve and is
+         * merely touching the other curve, as opposed to crossing it.
+         * 
+         * @see #isCrossing()
+         * 
+         * @return true if the location is an intersection that is
+         * merely touching another curve
+         */
+        isTouching(): boolean
+
+        /** 
+         * Checks if the location is an intersection with another curve and is
+         * crossing the other curve, as opposed to just touching it.
+         * 
+         * @see #isTouching()
+         * 
+         * @return true if the location is an intersection that is
+         * crossing another curve
+         */
+        isCrossing(): boolean
+
+        /** 
+         * Checks if the location is an intersection with another curve and is
+         * part of an overlap between the two involved paths.
+         * 
+         * @see #isCrossing()
+         * @see #isTouching()
+         * 
+         * @return true if the location is an intersection that is
+         * part of an overlap between the two involved paths
+         */
+        hasOverlap(): boolean
+
+    }
+
+    /** 
+     * The Event object is the base class for any of the other event types,
+     * such as {@link MouseEvent}, {@link ToolEvent} and {@link KeyEvent}.
+     */
+    class Event  {
+        /** 
+         * The time at which the event was created, in milliseconds since the epoch.
+         */
+        readonly timeStamp: number
+
+        /** 
+         * The current state of the keyboard modifiers.
+         * 
+         * @see Key.modifiers
+         */
+        readonly modifiers: object
+
+
+        /** 
+         * Cancels the event if it is cancelable, without stopping further
+         * propagation of the event.
+         */
+        preventDefault(): void
+
+        /** 
+         * Prevents further propagation of the current event.
+         */
+        stopPropagation(): void
+
+        /** 
+         * Cancels the event if it is cancelable, and stops stopping further
+         * propagation of the event. This is has the same effect as calling both
+         * {@link #stopPropagation} and {@link #preventDefault}.
+         * 
+         * Any handler can also return `false` to indicate that `stop()` should be
+         * called right after.
+         */
+        stop(): void
+
+    }
+
+    /** 
+     * The Gradient object.
+     */
+    class Gradient  {
+        /** 
+         * The gradient stops on the gradient ramp.
+         */
+        stops: GradientStop[]
+
+        /** 
+         * Specifies whether the gradient is radial or linear.
+         */
+        radial: boolean
+
+
+        /** 
+         * @return a copy of the gradient
+         */
+        clone(): Gradient
+
+        /** 
+         * Checks whether the gradient is equal to the supplied gradient.
+         * 
+         * @return true if they are equal
+         */
+        equals(gradient: Gradient): boolean
+
+    }
+
+    /** 
+     * The GradientStop object.
+     */
+    class GradientStop  {
+        /** 
+         * The ramp-point of the gradient stop as a value between `0` and `1`.
+         */
+        offset: number
+
+        /** 
+         * The color of the gradient stop.
+         */
+        color: Color
+
+
+        /** 
+         * Creates a GradientStop object.
+         * 
+         * @param color - the color of the stop
+         * @param offset - the position of the stop on the gradient
+         * ramp as a value between `0` and `1`; `null` or `undefined` for automatic
+         * assignment.
+         */
+        constructor(color?: Color, offset?: number)
+
+        /** 
+         * @return a copy of the gradient-stop
+         */
+        clone(): GradientStop
+
+    }
+
+    /** 
+     * A Group is a collection of items. When you transform a Group, its
+     * children are treated as a single unit without changing their relative
+     * positions.
+     */
+    class Group extends Item {
+        /** 
+         * Specifies whether the group item is to be clipped. When setting to
+         * `true`, the first child in the group is automatically defined as the
+         * clipping mask.
+         */
+        clipped: boolean
+
+
+        /** 
+         * Creates a new Group item and places it at the top of the active layer.
+         * 
+         * @param children - An array of children that will be added to the
+         * newly created group
+         */
+        constructor(children?: Item[])
+
+        /** 
+         * Creates a new Group item and places it at the top of the active layer.
+         * 
+         * @param object - an object containing the properties to be set on
+         *     the group
+         */
+        constructor(object: object)
+
+    }
+
+    /** 
+     * A HitResult object contains information about the results of a hit
+     * test. It is returned by {@link Item#hitTest} and
+     * {@link Project#hitTest}.
+     */
+    class HitResult  {
+        /** 
+         * Describes the type of the hit result. For example, if you hit a segment
+         * point, the type would be `'segment'`.
+         */
+        type: string
+
+        /** 
+         * If the HitResult has a {@link HitResult#type} of `'bounds'`, this
+         * property describes which corner of the bounding rectangle was hit.
+         */
+        name: string
+
+        /** 
+         * The item that was hit.
+         */
+        item: Item
+
+        /** 
+         * If the HitResult has a type of 'curve' or 'stroke', this property gives
+         * more information about the exact position that was hit on the path.
+         */
+        location: CurveLocation
+
+        /** 
+         * If the HitResult has a type of 'pixel', this property refers to the color
+         * of the pixel on the {@link Raster} that was hit.
+         */
+        color: Color
+
+        /** 
+         * If the HitResult has a type of 'stroke', 'segment', 'handle-in' or
+         * 'handle-out', this property refers to the segment that was hit or that
+         * is closest to the hitResult.location on the curve.
+         */
+        segment: Segment
+
+        /** 
+         * Describes the actual coordinates of the segment, handle or bounding box
+         * corner that was hit.
+         */
+        point: Point
+
+
+    }
+
+    /** 
+     * The Item type allows you to access and modify the items in
+     * Paper.js projects. Its functionality is inherited by different project
+     * item types such as {@link Path}, {@link CompoundPath}, {@link Group},
+     * {@link Layer} and {@link Raster}. They each add a layer of functionality that
+     * is unique to their type, but share the underlying properties and functions
+     * that they inherit from Item.
+     */
+    class Item  {
+        /** 
+         * The unique id of the item.
+         */
+        readonly id: number
+
+        /** 
+         * The class name of the item as a string.
+         */
+        className: string
+
+        /** 
+         * The name of the item. If the item has a name, it can be accessed by name
+         * through its parent's children list.
+         */
+        name: string
+
+        /** 
+         * The path style of the item.
+         */
+        style: Style
+
+        /** 
+         * Specifies whether the item is locked. When set to `true`, item
+         * interactions with the mouse are disabled.
+         */
+        locked: boolean
+
+        /** 
+         * Specifies whether the item is visible. When set to `false`, the item
+         * won't be drawn.
+         */
+        visible: boolean
+
+        /** 
+         * The blend mode with which the item is composited onto the canvas. Both
+         * the standard canvas compositing modes, as well as the new CSS blend modes
+         * are supported. If blend-modes cannot be rendered natively, they are
+         * emulated. Be aware that emulation can have an impact on performance.
+         */
+        blendMode: string
+
+        /** 
+         * The opacity of the item as a value between `0` and `1`.
+         */
+        opacity: number
+
+        /** 
+         * Specifies whether the item is selected. This will also return `true` for
+         * {@link Group} items if they are partially selected, e.g. groups
+         * containing selected or partially selected paths.
+         * 
+         * Paper.js draws the visual outlines of selected items on top of your
+         * project. This can be useful for debugging, as it allows you to see the
+         * construction of paths, position of path curves, individual segment points
+         * and bounding boxes of symbol and raster items.
+         * 
+         * @see Project#selectedItems
+         * @see Segment#selected
+         * @see Curve#selected
+         * @see Point#selected
+         */
+        selected: boolean
+
+        /** 
+         * Specifies whether the item defines a clip mask. This can only be set on
+         * paths, compound paths, and text frame objects, and only if the item is
+         * already contained within a clipping group.
+         */
+        clipMask: boolean
+
+        /** 
+         * A plain javascript object which can be used to store
+         * arbitrary data on the item.
+         */
+        data: object
+
+        /** 
+         * The item's position within the parent item's coordinate system. By
+         * default, this is the {@link Rectangle#center} of the item's
+         * {@link #bounds} rectangle.
+         */
+        position: Point
+
+        /** 
+         * The item's pivot point specified in the item coordinate system, defining
+         * the point around which all transformations are hinging. This is also the
+         * reference point for {@link #position}. By default, it is set to `null`,
+         * meaning the {@link Rectangle#center} of the item's {@link #bounds}
+         * rectangle is used as pivot.
+         */
+        pivot: Point
+
+        /** 
+         * The bounding rectangle of the item excluding stroke width.
+         */
+        bounds: Rectangle
+
+        /** 
+         * The bounding rectangle of the item including stroke width.
+         */
+        strokeBounds: Rectangle
+
+        /** 
+         * The bounding rectangle of the item including handles.
+         */
+        handleBounds: Rectangle
+
+        /** 
+         * The current rotation angle of the item, as described by its
+         * {@link #matrix}.
+         * Please note that this only returns meaningful values for items with
+         * {@link #applyMatrix} set to `false`, meaning they do not directly bake
+         * transformations into their content.
+         */
+        rotation: number
+
+        /** 
+         * The current scale factor of the item, as described by its
+         * {@link #matrix}.
+         * Please note that this only returns meaningful values for items with
+         * {@link #applyMatrix} set to `false`, meaning they do not directly bake
+         * transformations into their content.
+         */
+        scaling: Point
+
+        /** 
+         * The item's transformation matrix, defining position and dimensions in
+         * relation to its parent item in which it is contained.
+         */
+        matrix: Matrix
+
+        /** 
+         * The item's global transformation matrix in relation to the global project
+         * coordinate space. Note that the view's transformations resulting from
+         * zooming and panning are not factored in.
+         */
+        readonly globalMatrix: Matrix
+
+        /** 
+         * The item's global matrix in relation to the view coordinate space. This
+         * means that the view's transformations resulting from zooming and panning
+         * are factored in.
+         */
+        readonly viewMatrix: Matrix
+
+        /** 
+         * Controls whether the transformations applied to the item (e.g. through
+         * {@link #transform}, {@link #rotate},
+         * {@link #scale}, etc.) are stored in its {@link #matrix} property,
+         * or whether they are directly applied to its contents or children (passed
+         * on to the segments in {@link Path} items, the children of {@link Group}
+         * items, etc.).
+         */
+        applyMatrix: boolean
+
+        /** 
+         * The project that this item belongs to.
+         */
+        readonly project: Project
+
+        /** 
+         * The view that this item belongs to.
+         */
+        readonly view: View
+
+        /** 
+         * The layer that this item is contained within.
+         */
+        readonly layer: Layer
+
+        /** 
+         * The item that this item is contained within.
+         */
+        parent: Item
+
+        /** 
+         * The children items contained within this item. Items that define a
+         * {@link #name} can also be accessed by name.
+         * 
+         * <b>Please note:</b> The children array should not be modified directly
+         * using array functions. To remove single items from the children list, use
+         * {@link Item#remove}, to remove all items from the children list, use
+         * {@link Item#removeChildren}. To add items to the children list, use
+         * {@link Item#addChild} or {@link Item#insertChild}.
+         */
+        children: Item[]
+
+        /** 
+         * The first item contained within this item. This is a shortcut for
+         * accessing `item.children[0]`.
+         */
+        readonly firstChild: Item
+
+        /** 
+         * The last item contained within this item.This is a shortcut for
+         * accessing `item.children[item.children.length - 1]`.
+         */
+        readonly lastChild: Item
+
+        /** 
+         * The next item on the same level as this item.
+         */
+        readonly nextSibling: Item
+
+        /** 
+         * The previous item on the same level as this item.
+         */
+        readonly previousSibling: Item
+
+        /** 
+         * The index of this item within the list of its parent's children.
+         */
+        readonly index: number
+
+        /** 
+         * The color of the stroke.
+         */
+        strokeColor: Color
+
+        /** 
+         * The width of the stroke.
+         */
+        strokeWidth: number
+
+        /** 
+         * The shape to be used at the beginning and end of open {@link Path} items,
+         * when they have a stroke.
+         */
+        strokeCap: string
+
+        /** 
+         * The shape to be used at the segments and corners of {@link Path} items
+         * when they have a stroke.
+         */
+        strokeJoin: string
+
+        /** 
+         * The dash offset of the stroke.
+         */
+        dashOffset: number
+
+        /** 
+         * Specifies whether the stroke is to be drawn taking the current affine
+         * transformation into account (the default behavior), or whether it should
+         * appear as a non-scaling stroke.
+         */
+        strokeScaling: boolean
+
+        /** 
+         * Specifies an array containing the dash and gap lengths of the stroke.
+         */
+        dashArray: number[]
+
+        /** 
+         * The miter limit of the stroke.
+         * When two line segments meet at a sharp angle and miter joins have been
+         * specified for {@link Item#strokeJoin}, it is possible for the miter to
+         * extend far beyond the {@link Item#strokeWidth} of the path. The
+         * miterLimit imposes a limit on the ratio of the miter length to the
+         * {@link Item#strokeWidth}.
+         */
+        miterLimit: number
+
+        /** 
+         * The fill color of the item.
+         */
+        fillColor: Color
+
+        /** 
+         * The fill-rule with which the shape gets filled. Please note that only
+         * modern browsers support fill-rules other than `'nonzero'`.
+         */
+        fillRule: string
+
+        /** 
+         * The shadow color.
+         */
+        shadowColor: Color
+
+        /** 
+         * The shadow's blur radius.
+         */
+        shadowBlur: number
+
+        /** 
+         * The shadow's offset.
+         */
+        shadowOffset: Point
+
+        /** 
+         * The color the item is highlighted with when selected. If the item does
+         * not specify its own color, the color defined by its layer is used instead.
+         */
+        selectedColor: Color
+
+        /** 
+         * Item level handler function to be called on each frame of an animation.
+         * The function receives an event object which contains information about
+         * the frame event:
+         * 
+         * @see View#onFrame
+         * 
+         * @option event.count {Number} the number of times the frame event was
+         *     fired
+         * @option event.time {Number} the total amount of time passed since the
+         *     first frame event in seconds
+         * @option event.delta {Number} the time passed in seconds since the last
+         *     frame event
+         */
+        onFrame: Function
+
+        /** 
+         * The function to be called when the mouse button is pushed down on the
+         * item. The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseDown
+         */
+        onMouseDown: Function
+
+        /** 
+         * The function to be called when the mouse position changes while the mouse
+         * is being dragged over the item. The function receives a {@link
+         * MouseEvent} object which contains information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseDrag
+         */
+        onMouseDrag: Function
+
+        /** 
+         * The function to be called when the mouse button is released over the item.
+         * The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseUp
+         */
+        onMouseUp: Function
+
+        /** 
+         * The function to be called when the mouse clicks on the item. The function
+         * receives a {@link MouseEvent} object which contains information about the
+         * mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onClick
+         */
+        onClick: Function
+
+        /** 
+         * The function to be called when the mouse double clicks on the item. The
+         * function receives a {@link MouseEvent} object which contains information
+         * about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onDoubleClick
+         */
+        onDoubleClick: Function
+
+        /** 
+         * The function to be called repeatedly while the mouse moves over the item.
+         * The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseMove
+         */
+        onMouseMove: Function
+
+        /** 
+         * The function to be called when the mouse moves over the item. This
+         * function will only be called again, once the mouse moved outside of the
+         * item first. The function receives a {@link MouseEvent} object which
+         * contains information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseEnter
+         */
+        onMouseEnter: Function
+
+        /** 
+         * The function to be called when the mouse moves out of the item.
+         * The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy and will
+         * reach the view, unless they are stopped with {@link
+         * Event#stopPropagation()} or by returning `false` from the handler.
+         * 
+         * @see View#onMouseLeave
+         */
+        onMouseLeave: Function
+
+
+        /** 
+         * Checks if the item contains any children items.
+         * 
+         * @return true it has one or more children
+         */
+        hasChildren(): boolean
+
+        /** 
+         * Sets the properties of the passed object literal on this item to the
+         * values defined in the object literal, if the item has property of the
+         * given name (or a setter defined for it).
+         * 
+         * @return the item itself
+         */
+        set(props: object): Item
+
+        /** 
+         * Copies the content of the specified item over to this item.
+         * 
+         * @param source - the item to copy the content from
+         */
+        copyContent(source: Item): void
+
+        /** 
+         * Copies all attributes of the specified item over to this item. This
+         * includes its style, visibility, matrix, pivot, blend-mode, opacity,
+         * selection state, data, name, etc.
+         * 
+         * @param source - the item to copy the attributes from
+         * @param excludeMatrix - whether to exclude the transformation
+         * matrix when copying all attributes
+         */
+        copyAttributes(source: Item, excludeMatrix: boolean): void
+
+        /** 
+         * Rasterizes the item into a newly created Raster object. The item itself
+         * is not removed after rasterization.
+         * 
+         * @param resolution - the resolution of the raster
+         *     in pixels per inch (DPI). If not specified, the value of
+         *     `view.resolution` is used.
+         * @param insert - specifies whether the raster should be
+         *     inserted into the scene graph. When set to `true`, it is inserted
+         *     above the original
+         * 
+         * @return the newly created raster item
+         */
+        rasterize(resolution?: number, insert?: boolean): Raster
+
+        /** 
+         * Checks whether the item's geometry contains the given point.
+         * 
+         * @param point - the point to check for
+         */
+        contains(point: Point): boolean
+
+        /** 
+         * @param rect - the rectangle to check against
+         */
+        isInside(rect: Rectangle): boolean
+
+        /** 
+         * @param item - the item to check against
+         */
+        intersects(item: Item): boolean
+
+        /** 
+         * Performs a hit-test on the item and its children (if it is a {@link
+         * Group} or {@link Layer}) at the location of the specified point,
+         * returning the first found hit.
+         * 
+         * The options object allows you to control the specifics of the hit-
+         * test and may contain a combination of the following values:
+         * 
+         * @option [options.tolerance={@link PaperScope#settings}.hitTolerance]
+         *     {Number} the tolerance of the hit-test
+         * @option options.class {Function} only hit-test against a specific item
+         *     class, or any of its sub-classes, by providing the constructor
+         *     function against which an `instanceof` check is performed:
+         *     {@values  Group, Layer, Path, CompoundPath, Shape, Raster,
+         *     SymbolItem, PointText, ...}
+         * @option options.match {Function} a match function to be called for each
+         *     found hit result: Return `true` to return the result, `false` to keep
+         *     searching
+         * @option [options.fill=true] {Boolean} hit-test the fill of items
+         * @option [options.stroke=true] {Boolean} hit-test the stroke of path
+         *     items, taking into account the setting of stroke color and width
+         * @option [options.segments=true] {Boolean} hit-test for {@link
+         *     Segment#point} of {@link Path} items
+         * @option options.curves {Boolean} hit-test the curves of path items,
+         *     without taking the stroke color or width into account
+         * @option options.handles {Boolean} hit-test for the handles ({@link
+         *     Segment#handleIn} / {@link Segment#handleOut}) of path segments.
+         * @option options.ends {Boolean} only hit-test for the first or last
+         *     segment points of open path items
+         * @option options.position {Boolean} hit-test the {@link Item#position} of
+         *     of items, which depends on the setting of {@link Item#pivot}
+         * @option options.center {Boolean} hit-test the {@link Rectangle#center} of
+         *     the bounding rectangle of items ({@link Item#bounds})
+         * @option options.bounds {Boolean} hit-test the corners and side-centers of
+         *     the bounding rectangle of items ({@link Item#bounds})
+         * @option options.guides {Boolean} hit-test items that have {@link
+         *     Item#guide} set to `true`
+         * @option options.selected {Boolean} only hit selected items
+         * 
+         * @param point - the point where the hit-test should be performed
+         *     (in global coordinates system).
+         * 
+         * @return a hit result object describing what exactly was hit
+         *     or `null` if nothing was hit
+         */
+        hitTest(point: Point, options?: object): HitResult
+
+        /** 
+         * Performs a hit-test on the item and its children (if it is a {@link
+         * Group} or {@link Layer}) at the location of the specified point,
+         * returning all found hits.
+         * 
+         * The options object allows you to control the specifics of the hit-
+         * test. See {@link #hitTest} for a list of all options.
+         * 
+         * @see #hitTest(point[, options]);
+         * 
+         * @param point - the point where the hit-test should be performed
+         *     (in global coordinates system).
+         * 
+         * @return hit result objects for all hits, describing what
+         *     exactly was hit or `null` if nothing was hit
+         */
+        hitTestAll(point: Point, options?: object): HitResult[]
+
+        /** 
+         * Checks whether the item matches the criteria described by the given
+         * object, by iterating over all of its properties and matching against
+         * their values through {@link #matches}.
+         * 
+         * See {@link Project#getItems} for a selection of illustrated
+         * examples.
+         * 
+         * @see #getItems(options)
+         * 
+         * @param options - the criteria to match against
+         * 
+         * @return true if the item matches all the criteria
+         */
+        matches(options: object | Function): boolean
+
+        /** 
+         * Checks whether the item matches the given criteria. Extended matching is
+         * possible by providing a compare function or a regular expression.
+         * Matching points, colors only work as a comparison of the full object, not
+         * partial matching (e.g. only providing the x-coordinate to match all
+         * points with that x-value). Partial matching does work for
+         * {@link Item#data}.
+         * 
+         * See {@link Project#getItems} for a selection of illustrated
+         * examples.
+         * 
+         * @see #getItems(options)
+         * 
+         * @param name - the name of the state to match against
+         * @param compare - the value, function or regular expression to
+         * compare against
+         * 
+         * @return true if the item matches the state
+         */
+        matches(name: string, compare: object): boolean
+
+        /** 
+         * Fetch the descendants (children or children of children) of this item
+         * that match the properties in the specified object. Extended matching is
+         * possible by providing a compare function or regular expression. Matching
+         * points, colors only work as a comparison of the full object, not partial
+         * matching (e.g. only providing the x- coordinate to match all points with
+         * that x-value). Partial matching does work for {@link Item#data}.
+         * 
+         * Matching items against a rectangular area is also possible, by setting
+         * either `options.inside` or `options.overlapping` to a rectangle describing
+         * the area in which the items either have to be fully or partly contained.
+         * 
+         * See {@link Project#getItems} for a selection of illustrated
+         * examples.
+         * 
+         * @see #matches(options)
+         * 
+         * @option [options.recursive=true] {Boolean} whether to loop recursively
+         *     through all children, or stop at the current level
+         * @option options.match {Function} a match function to be called for each
+         *     item, allowing the definition of more flexible item checks that are
+         *     not bound to properties. If no other match properties are defined,
+         *     this function can also be passed instead of the `options` object
+         * @option options.class {Function} the constructor function of the item type
+         *     to match against
+         * @option options.inside {Rectangle} the rectangle in which the items need to
+         *     be fully contained
+         * @option options.overlapping {Rectangle} the rectangle with which the items
+         *     need to at least partly overlap
+         * 
+         * @param options - the criteria to match against
+         * 
+         * @return the list of matching descendant items
+         */
+        getItems(options: object | Function): Item[]
+
+        /** 
+         * Fetch the first descendant (child or child of child) of this item
+         * that matches the properties in the specified object.
+         * Extended matching is possible by providing a compare function or
+         * regular expression. Matching points, colors only work as a comparison
+         * of the full object, not partial matching (e.g. only providing the x-
+         * coordinate to match all points with that x-value). Partial matching
+         * does work for {@link Item#data}.
+         * See {@link Project#getItems} for a selection of illustrated
+         * examples.
+         * 
+         * @see #getItems(match)
+         * 
+         * @param match - the criteria to match against
+         * 
+         * @return the first descendant item matching the given criteria
+         */
+        getItem(match: object | Function): Item
+
+        /** 
+         * Exports (serializes) the item with its content and child items to a JSON
+         * data string.
+         * 
+         * @option [options.asString=true] {Boolean} whether the JSON is returned as
+         *     a `Object` or a `String`
+         * @option [options.precision=5] {Number} the amount of fractional digits in
+         *     numbers used in JSON data
+         * 
+         * @param options - the serialization options
+         * 
+         * @return the exported JSON data
+         */
+        exportJSON(options?: object): string
+
+        /** 
+         * Imports (deserializes) the stored JSON data into this item. If the data
+         * describes an item of the same class or a parent class of the item, the
+         * data is imported into the item itself. If not, the imported item is added
+         * to this item's {@link Item#children} list. Note that not all type of
+         * items can have children.
+         * 
+         * @param json - the JSON data to import from
+         */
+        importJSON(json: string): Item
+
+        /** 
+         * Exports the item with its content and child items as an SVG DOM.
+         * 
+         * @option [options.bounds='view'] {String|Rectangle} the bounds of the area
+         *     to export, either as a string ({@values 'view', content'}), or a
+         *     {@link Rectangle} object: `'view'` uses the view bounds,
+         *     `'content'` uses the stroke bounds of all content
+         * @option [options.matrix=paper.view.matrix] {Matrix} the matrix with which
+         *     to transform the exported content: If `options.bounds` is set to
+         *     `'view'`, `paper.view.matrix` is used, for all other settings of
+         *     `options.bounds` the identity matrix is used.
+         * @option [options.asString=false] {Boolean} whether a SVG node or a
+         *     `String` is to be returned
+         * @option [options.precision=5] {Number} the amount of fractional digits in
+         *     numbers used in SVG data
+         * @option [options.matchShapes=false] {Boolean} whether path items should
+         *     tried to be converted to SVG shape items (rect, circle, ellipse,
+         *     line, polyline, polygon), if their geometries match
+         * @option [options.embedImages=true] {Boolean} whether raster images should
+         *     be embedded as base64 data inlined in the xlink:href attribute, or
+         *     kept as a link to their external URL.
+         * 
+         * @param options - the export options
+         * 
+         * @return the item converted to an SVG node or a
+         * `String` depending on `option.asString` value
+         */
+        exportSVG(options?: object): SVGElement | string
+
+        /** 
+         * Converts the provided SVG content into Paper.js items and adds them to
+         * the this item's children list. Note that the item is not cleared first.
+         * You can call {@link Item#removeChildren} to do so.
+         * 
+         * @option [options.expandShapes=false] {Boolean} whether imported shape
+         *     items should be expanded to path items
+         * @option options.onLoad {Function} the callback function to call once the
+         *     SVG content is loaded from the given URL receiving two arguments: the
+         *     converted `item` and the original `svg` data as a string. Only
+         *     required when loading from external resources.
+         * @option options.onError {Function} the callback function to call if an
+         *     error occurs during loading. Only required when loading from external
+         *     resources.
+         * @option [options.insert=true] {Boolean} whether the imported items should
+         *     be added to the item that `importSVG()` is called on
+         * @option [options.applyMatrix={@link PaperScope#settings}.applyMatrix]
+         *     {Boolean} whether the imported items should have their transformation
+         *     matrices applied to their contents or not
+         * 
+         * @param svg - the SVG content to import, either as a SVG
+         *     DOM node, a string containing SVG content, or a string describing the
+         *     URL of the SVG file to fetch.
+         * @param options - the import options
+         * 
+         * @return the newly created Paper.js item containing the converted
+         *     SVG content
+         */
+        importSVG(svg: SVGElement | string, options?: object): Item
+
+        /** 
+         * Imports the provided external SVG file, converts it into Paper.js items
+         * and adds them to the this item's children list. Note that the item is not
+         * cleared first. You can call {@link Item#removeChildren} to do so.
+         * 
+         * @param svg - the URL of the SVG file to fetch.
+         * @param onLoad - the callback function to call once the SVG
+         *     content is loaded from the given URL receiving two arguments: the
+         *     converted `item` and the original `svg` data as a string. Only
+         *     required when loading from external files.
+         * 
+         * @return the newly created Paper.js item containing the converted
+         *     SVG content
+         */
+        importSVG(svg: SVGElement | string, onLoad: Function): Item
+
+        /** 
+         * Adds the specified item as a child of this item at the end of the its
+         * {@link #children}  list. You can use this function for groups, compound
+         * paths and layers.
+         * 
+         * @param item - the item to be added as a child
+         * 
+         * @return the added item, or `null` if adding was not possible
+         */
+        addChild(item: Item): Item
+
+        /** 
+         * Inserts the specified item as a child of this item at the specified index
+         * in its {@link #children} list. You can use this function for groups,
+         * compound paths and layers.
+         * 
+         * @param index - the index at which to insert the item
+         * @param item - the item to be inserted as a child
+         * 
+         * @return the inserted item, or `null` if inserting was not possible
+         */
+        insertChild(index: number, item: Item): Item
+
+        /** 
+         * Adds the specified items as children of this item at the end of the its
+         * children list. You can use this function for groups, compound paths and
+         * layers.
+         * 
+         * @param items - the items to be added as children
+         * 
+         * @return the added items, or `null` if adding was not possible
+         */
+        addChildren(items: Item[]): Item[]
+
+        /** 
+         * Inserts the specified items as children of this item at the specified
+         * index in its {@link #children} list. You can use this function for
+         * groups, compound paths and layers.
+         * 
+         * @param items - the items to be appended as children
+         * 
+         * @return the inserted items, or `null` if inserted was not
+         *     possible
+         */
+        insertChildren(index: number, items: Item[]): Item[]
+
+        /** 
+         * Inserts this item above the specified item.
+         * 
+         * @param item - the item above which it should be inserted
+         * 
+         * @return the inserted item, or `null` if inserting was not possible
+         */
+        insertAbove(item: Item): Item
+
+        /** 
+         * Inserts this item below the specified item.
+         * 
+         * @param item - the item below which it should be inserted
+         * 
+         * @return the inserted item, or `null` if inserting was not possible
+         */
+        insertBelow(item: Item): Item
+
+        /** 
+         * Sends this item to the back of all other items within the same parent.
+         */
+        sendToBack(): void
+
+        /** 
+         * Brings this item to the front of all other items within the same parent.
+         */
+        bringToFront(): void
+
+        /** 
+         * Adds it to the specified owner, which can be either a {@link Item} or a
+         * {@link Project}.
+         * 
+         * @param owner - the item or project to
+         * add the item to
+         * 
+         * @return the item itself, if it was successfully added
+         */
+        addTo(owner: Project | Layer | Group | CompoundPath): Item
+
+        /** 
+         * Clones the item and adds it to the specified owner, which can be either
+         * a {@link Item} or a {@link Project}.
+         * 
+         * @param owner - the item or project to
+         * copy the item to
+         * 
+         * @return the new copy of the item, if it was successfully added
+         */
+        copyTo(owner: Project | Layer | Group | CompoundPath): Item
+
+        /** 
+         * If this is a group, layer or compound-path with only one child-item,
+         * the child-item is moved outside and the parent is erased. Otherwise, the
+         * item itself is returned unmodified.
+         * 
+         * @return the reduced item
+         */
+        reduce(options: any): Item
+
+        /** 
+         * Removes the item and all its children from the project. The item is not
+         * destroyed and can be inserted again after removal.
+         * 
+         * @return true if the item was removed
+         */
+        remove(): boolean
+
+        /** 
+         * Replaces this item with the provided new item which will takes its place
+         * in the project hierarchy instead.
+         * 
+         * @param item - the item that will replace this item
+         * 
+         * @return true if the item was replaced
+         */
+        replaceWith(item: Item): boolean
+
+        /** 
+         * Removes all of the item's {@link #children} (if any).
+         * 
+         * @return an array containing the removed items
+         */
+        removeChildren(): Item[]
+
+        /** 
+         * Removes the children from the specified `start` index to and excluding
+         * the `end` index from the parent's {@link #children} array.
+         * 
+         * @param start - the beginning index, inclusive
+         * @param end - the ending index, exclusive
+         * 
+         * @return an array containing the removed items
+         */
+        removeChildren(start: number, end?: number): Item[]
+
+        /** 
+         * Reverses the order of the item's children
+         */
+        reverseChildren(): void
+
+        /** 
+         * Specifies whether the item has any content or not. The meaning of what
+         * content is differs from type to type. For example, a {@link Group} with
+         * no children, a {@link TextItem} with no text content and a {@link Path}
+         * with no segments all are considered empty.
+         */
+        isEmpty(): boolean
+
+        /** 
+         * Checks whether the item has a fill.
+         * 
+         * @return true if the item has a fill
+         */
+        hasFill(): boolean
+
+        /** 
+         * Checks whether the item has a stroke.
+         * 
+         * @return true if the item has a stroke
+         */
+        hasStroke(): boolean
+
+        /** 
+         * Checks whether the item has a shadow.
+         * 
+         * @return true if the item has a shadow
+         */
+        hasShadow(): boolean
+
+        /** 
+         * Clones the item within the same project and places the copy above the
+         * item.
+         * 
+         * @option [insert=true] specifies whether the copy should be
+         *     inserted into the scene graph. When set to `true`, it is inserted
+         *     above the original
+         * @option [deep=true] specifies whether the item's children should also be
+         *     cloned
+         * 
+         * @return the newly cloned item
+         */
+        clone(options?: object): Item
+
+        /** 
+         * Checks whether the item and all its parents are inserted into scene graph
+         * or not.
+         * 
+         * @return true if the item is inserted into the scene graph
+         */
+        isInserted(): boolean
+
+        /** 
+         * Checks if this item is above the specified item in the stacking order
+         * of the project.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if it is above the specified item
+         */
+        isAbove(item: Item): boolean
+
+        /** 
+         * Checks if the item is below the specified item in the stacking order of
+         * the project.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if it is below the specified item
+         */
+        isBelow(item: Item): boolean
+
+        /** 
+         * Checks whether the specified item is the parent of the item.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if it is the parent of the item
+         */
+        isParent(item: Item): boolean
+
+        /** 
+         * Checks whether the specified item is a child of the item.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true it is a child of the item
+         */
+        isChild(item: Item): boolean
+
+        /** 
+         * Checks if the item is contained within the specified item.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if it is inside the specified item
+         */
+        isDescendant(item: Item): boolean
+
+        /** 
+         * Checks if the item is an ancestor of the specified item.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if the item is an ancestor of the specified
+         * item
+         */
+        isAncestor(item: Item): boolean
+
+        /** 
+         * Checks if the item is an a sibling of the specified item.
+         * 
+         * @param item - the item to check against
+         * 
+         * @return true if the item is aa sibling of the specified item
+         */
+        isSibling(item: Item): boolean
+
+        /** 
+         * Checks whether the item is grouped with the specified item.
+         * 
+         * @return true if the items are grouped together
+         */
+        isGroupedWith(item: Item): boolean
+
+        /** 
+         * Translates (moves) the item by the given offset views.
+         * 
+         * @param delta - the offset to translate the item by
+         */
+        translate(delta: Point): void
+
+        /** 
+         * Rotates the item by a given angle around the given center point.
+         * 
+         * Angles are oriented clockwise and measured in degrees.
+         * 
+         * @see Matrix#rotate(angle[, center])
+         * 
+         * @param angle - the rotation angle
+         */
+        rotate(angle: number, center?: Point): void
+
+        /** 
+         * Scales the item by the given value from its center point, or optionally
+         * from a supplied point.
+         * 
+         * @param scale - the scale factor
+         */
+        scale(scale: number, center?: Point): void
+
+        /** 
+         * Scales the item by the given values from its center point, or optionally
+         * from a supplied point.
+         * 
+         * @param hor - the horizontal scale factor
+         * @param ver - the vertical scale factor
+         */
+        scale(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Shears the item by the given value from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(shear[, center])
+         * 
+         * @param shear - the horziontal and vertical shear factors as a point
+         */
+        shear(shear: Point, center?: Point): void
+
+        /** 
+         * Shears the item by the given values from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(hor, ver[, center])
+         * 
+         * @param hor - the horizontal shear factor
+         * @param ver - the vertical shear factor
+         */
+        shear(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Skews the item by the given angles from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(skew[, center])
+         * 
+         * @param skew - the horziontal and vertical skew angles in degrees
+         */
+        skew(skew: Point, center?: Point): void
+
+        /** 
+         * Skews the item by the given angles from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(hor, ver[, center])
+         * 
+         * @param hor - the horizontal skew angle in degrees
+         * @param ver - the vertical sskew angle in degrees
+         */
+        skew(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Transform the item.
+         * 
+         * @param matrix - the matrix by which the item shall be transformed
+         */
+        transform(matrix: Matrix): void
+
+        /** 
+         * Converts the specified point from global project coordinate space to the
+         * item's own local coordinate space.
+         * 
+         * @param point - the point to be transformed
+         * 
+         * @return the transformed point as a new instance
+         */
+        globalToLocal(point: Point): Point
+
+        /** 
+         * Converts the specified point from the item's own local coordinate space
+         * to the global project coordinate space.
+         * 
+         * @param point - the point to be transformed
+         * 
+         * @return the transformed point as a new instance
+         */
+        localToGlobal(point: Point): Point
+
+        /** 
+         * Converts the specified point from the parent's coordinate space to
+         * item's own local coordinate space.
+         * 
+         * @param point - the point to be transformed
+         * 
+         * @return the transformed point as a new instance
+         */
+        parentToLocal(point: Point): Point
+
+        /** 
+         * Converts the specified point from the item's own local coordinate space
+         * to the parent's coordinate space.
+         * 
+         * @param point - the point to be transformed
+         * 
+         * @return the transformed point as a new instance
+         */
+        localToParent(point: Point): Point
+
+        /** 
+         * Transform the item so that its {@link #bounds} fit within the specified
+         * rectangle, without changing its aspect ratio.
+         */
+        fitBounds(rectangle: Rectangle, fill?: boolean): void
+
+        /** 
+         * Attaches an event handler to the item.
+         * 
+         * @param type - the type of event: {@values 'frame', mousedown',
+         *     'mouseup', 'mousedrag', 'click', 'doubleclick', 'mousemove',
+         *     'mouseenter', 'mouseleave'}
+         * @param function - the function to be called when the event
+         *     occurs, receiving a {@link MouseEvent} or {@link Event} object as its
+         *     sole argument
+         * 
+         * @return this item itself, so calls can be chained
+         */
+        on(type: string, callback: Function): Item
+
+        /** 
+         * Attaches one or more event handlers to the item.
+         * 
+         * @param object - an object containing one or more of the following
+         *     properties: {@values frame, mousedown, mouseup, mousedrag, click,
+         *     doubleclick, mousemove, mouseenter, mouseleave}
+         * 
+         * @return this item itself, so calls can be chained
+         */
+        on(object: object): Item
+
+        /** 
+         * Detach an event handler from the item.
+         * 
+         * @param type - the type of event: {@values 'frame', mousedown',
+         *     'mouseup', 'mousedrag', 'click', 'doubleclick', 'mousemove',
+         *     'mouseenter', 'mouseleave'}
+         * @param function - the function to be detached
+         * 
+         * @return this item itself, so calls can be chained
+         */
+        off(type: string, callback: Function): Item
+
+        /** 
+         * Detach one or more event handlers to the item.
+         * 
+         * @param object - an object containing one or more of the following
+         *     properties: {@values frame, mousedown, mouseup, mousedrag, click,
+         *     doubleclick, mousemove, mouseenter, mouseleave}
+         * 
+         * @return this item itself, so calls can be chained
+         */
+        off(object: object): Item
+
+        /** 
+         * Emit an event on the item.
+         * 
+         * @param type - the type of event: {@values 'frame', mousedown',
+         *     'mouseup', 'mousedrag', 'click', 'doubleclick', 'mousemove',
+         *     'mouseenter', 'mouseleave'}
+         * @param event - an object literal containing properties describing
+         * the event
+         * 
+         * @return true if the event had listeners
+         */
+        emit(type: string, event: object): boolean
+
+        /** 
+         * Check if the item has one or more event handlers of the specified type.
+         * 
+         * @param type - the type of event: {@values 'frame', mousedown',
+         *     'mouseup', 'mousedrag', 'click', 'doubleclick', 'mousemove',
+         *     'mouseenter', 'mouseleave'}
+         * 
+         * @return true if the item has one or more event handlers of
+         * the specified type
+         */
+        responds(type: string): boolean
+
+        /** 
+         * Removes the item when the events specified in the passed options object
+         * occur.
+         * 
+         * @option options.move {Boolean) remove the item when the next {@link
+         *     Tool#onMouseMove} event is fired.
+         * @option options.drag {Boolena) remove the item when the next {@link
+         *     Tool#onMouseDrag} event is fired.
+         * @option options.down {Boolean) remove the item when the next {@link
+         *     Tool#onMouseDown} event is fired.
+         * @option options.up {Boolean) remove the item when the next {@link
+         *     Tool#onMouseUp} event is fired.
+         */
+        removeOn(options: object): void
+
+        /** 
+         * Removes the item when the next {@link Tool#onMouseMove} event is fired.
+         */
+        removeOnMove(): void
+
+        /** 
+         * Removes the item when the next {@link Tool#onMouseDown} event is fired.
+         */
+        removeOnDown(): void
+
+        /** 
+         * Removes the item when the next {@link Tool#onMouseDrag} event is fired.
+         */
+        removeOnDrag(): void
+
+        /** 
+         * Removes the item when the next {@link Tool#onMouseUp} event is fired.
+         */
+        removeOnUp(): void
+
+        /** 
+         * Tween item between two states.
+         * 
+         * @option options.duration {Number} the duration of the tweening
+         * @option [options.easing='linear'] {Function|String} an easing function or the type
+         * of the easing: {@values 'linear' 'easeInQuad' 'easeOutQuad'
+         * 'easeInOutQuad' 'easeInCubic' 'easeOutCubic' 'easeInOutCubic'
+         * 'easeInQuart' 'easeOutQuart' 'easeInOutQuart' 'easeInQuint'
+         * 'easeOutQuint' 'easeInOutQuint'}
+         * @option [options.start=true] {Boolean} whether to start tweening automatically
+         * 
+         * @param from - the state at the start of the tweening
+         * @param to - the state at the end of the tweening
+         * @param options - the options or the duration
+         */
+        tween(from: object, to: object, options: object | number): Tween
+
+        /** 
+         * Tween item to a state.
+         * 
+         * @see Item#tween(from, to, options)
+         * 
+         * @param to - the state at the end of the tweening
+         * @param options - the options or the duration
+         */
+        tween(to: object, options: object | number): Tween
+
+        /** 
+         * Tween item.
+         * 
+         * @see Item#tween(from, to, options)
+         * 
+         * @param options - the options or the duration
+         */
+        tween(options: object | number): Tween
+
+        /** 
+         * Tween item to a state.
+         * 
+         * @see Item#tween(to, options)
+         * 
+         * @param to - the state at the end of the tweening
+         * @param options - the options or the duration
+         */
+        tweenTo(to: object, options: object | number): Tween
+
+        /** 
+         * Tween item from a state to its state before the tweening.
+         * 
+         * @see Item#tween(from, to, options)
+         * 
+         * @param from - the state at the start of the tweening
+         * @param options - the options or the duration
+         */
+        tweenFrom(from: object, options: object | number): Tween
+
+    }
+
+    
+    class Key  {
+        /** 
+         * The current state of the keyboard modifiers.
+         * 
+         * @option modifiers.shift {Boolean} {@true if the shift key is
+         *     pressed}.
+         * @option modifiers.control {Boolean} {@true if the control key is
+         *     pressed}.
+         * @option modifiers.alt {Boolean} {@true if the alt/option key is
+         *     pressed}.
+         * @option modifiers.meta {Boolean} {@true if the meta/windows/command
+         *     key is pressed}.
+         * @option modifiers.capsLock {Boolean} {@true if the caps-lock key is
+         *     active}.
+         * @option modifiers.space {Boolean} {@true if the space key is
+         *     pressed}.
+         * @option modifiers.option {Boolean} {@true if the alt/option key is
+         *     pressed}. This is the same as `modifiers.alt`
+         * @option modifiers.command {Boolean} {@true if the meta key is pressed
+         *     on Mac, or the control key is pressed on Windows and Linux}.
+         */
+        static modifiers: object
+
+
+        /** 
+         * Checks whether the specified key is pressed.
+         * 
+         * @param key - any character or special key descriptor:
+         *     {@values 'enter', 'space', 'shift', 'control', 'alt', 'meta',
+         *     'caps-lock', 'left', 'up', 'right', 'down', 'escape', 'delete',
+         *     ...}
+         * 
+         * @return true if the key is pressed
+         */
+        static isDown(key: string): boolean
+
+    }
+
+    /** 
+     * The KeyEvent object is received by the {@link Tool}'s keyboard
+     * handlers {@link Tool#onKeyDown}, {@link Tool#onKeyUp}. The KeyEvent object is
+     * the only parameter passed to these functions and contains information about
+     * the keyboard event.
+     */
+    class KeyEvent extends Event {
+        /** 
+         * The type of mouse event.
+         */
+        type: string
+
+        /** 
+         * The character representation of the key that caused this key event,
+         * taking into account the current key-modifiers (e.g. shift, control,
+         * caps-lock, etc.)
+         */
+        character: string
+
+        /** 
+         * The key that caused this key event, either as a lower-case character or
+         * special key descriptor.
+         */
+        key: string
+
+
+        /** 
+         * @return a string representation of the key event
+         */
+        toString(): string
+
+    }
+
+    /** 
+     * The Layer item represents a layer in a Paper.js project.
+     * 
+     * The layer which is currently active can be accessed through
+     * {@link Project#activeLayer}.
+     * An array of all layers in a project can be accessed through
+     * {@link Project#layers}.
+     */
+    class Layer extends Group {
+
+        /** 
+         * Creates a new Layer item and places it at the end of the
+         * {@link Project#layers} array. The newly created layer will be activated,
+         * so all newly created items will be placed within it.
+         * 
+         * @param children - An array of items that will be added to the
+         * newly created layer
+         */
+        constructor(children?: Item[])
+
+        /** 
+         * Creates a new Layer item and places it at the end of the
+         * {@link Project#layers} array. The newly created layer will be activated,
+         * so all newly created items will be placed within it.
+         * 
+         * @param object - an object containing the properties to be set on
+         *     the layer
+         */
+        constructor(object: object)
+
+        /** 
+         * Activates the layer.
+         */
+        activate(): void
+
+    }
+
+    /** 
+     * An affine transformation matrix performs a linear mapping from 2D
+     *     coordinates to other 2D coordinates that preserves the "straightness" and
+     *     "parallelness" of lines.
+     * 
+     * Such a coordinate transformation can be represented by a 3 row by 3
+     * column matrix with an implied last row of `[ 0 0 1 ]`. This matrix
+     * transforms source coordinates `(x, y)` into destination coordinates `(x',y')`
+     * by considering them to be a column vector and multiplying the coordinate
+     * vector by the matrix according to the following process:
+     * 
+     *     [ x ]   [ a  c  tx ] [ x ]   [ a * x + c * y + tx ]
+     *     [ y ] = [ b  d  ty ] [ y ] = [ b * x + d * y + ty ]
+     *     [ 1 ]   [ 0  0  1  ] [ 1 ]   [         1          ]
+     * 
+     * Note the locations of b and c.
+     * 
+     * This class is optimized for speed and minimizes calculations based on its
+     * knowledge of the underlying matrix (as opposed to say simply performing
+     * matrix multiplication).
+     */
+    class Matrix  {
+        /** 
+         * The value that affects the transformation along the x axis when scaling
+         * or rotating, positioned at (0, 0) in the transformation matrix.
+         */
+        a: number
+
+        /** 
+         * The value that affects the transformation along the y axis when rotating
+         * or skewing, positioned at (1, 0) in the transformation matrix.
+         */
+        b: number
+
+        /** 
+         * The value that affects the transformation along the x axis when rotating
+         * or skewing, positioned at (0, 1) in the transformation matrix.
+         */
+        c: number
+
+        /** 
+         * The value that affects the transformation along the y axis when scaling
+         * or rotating, positioned at (1, 1) in the transformation matrix.
+         */
+        d: number
+
+        /** 
+         * The distance by which to translate along the x axis, positioned at (2, 0)
+         * in the transformation matrix.
+         */
+        tx: number
+
+        /** 
+         * The distance by which to translate along the y axis, positioned at (2, 1)
+         * in the transformation matrix.
+         */
+        ty: number
+
+        /** 
+         * The matrix values as an array, in the same sequence as they are passed
+         * to {@link #initialize}.
+         */
+        readonly values: number[]
+
+        /** 
+         * The translation of the matrix as a vector.
+         */
+        readonly translation: Point
+
+        /** 
+         * The scaling values of the matrix, if it can be decomposed.
+         * 
+         * @see #decompose()
+         */
+        readonly scaling: Point
+
+        /** 
+         * The rotation angle of the matrix, if it can be decomposed.
+         * 
+         * @see #decompose()
+         */
+        readonly rotation: number
+
+
+        /** 
+         * Creates a 2D affine transformation matrix that describes the identity
+         * transformation.
+         */
+        constructor()
+
+        /** 
+         * Creates a 2D affine transformation matrix.
+         * 
+         * @param values - the matrix values to initialize this matrix with
+         */
+        constructor(values: number[])
+
+        /** 
+         * Creates a 2D affine transformation matrix.
+         * 
+         * @param matrix - the matrix to copy the values from
+         */
+        constructor(matrix: Matrix)
+
+        /** 
+         * Creates a 2D affine transformation matrix.
+         * 
+         * @param a - the a property of the transform
+         * @param b - the b property of the transform
+         * @param c - the c property of the transform
+         * @param d - the d property of the transform
+         * @param tx - the tx property of the transform
+         * @param ty - the ty property of the transform
+         */
+        constructor(a: number, b: number, c: number, d: number, tx: number, ty: number)
+
+        /** 
+         * Sets the matrix to the passed values. Note that any sequence of
+         * parameters that is supported by the various {@link Matrix} constructors
+         * also work for calls of `set()`.
+         */
+        set(...value: any[]): Point
+
+        /** 
+         * @return a copy of this transform
+         */
+        clone(): Matrix
+
+        /** 
+         * Checks whether the two matrices describe the same transformation.
+         * 
+         * @param matrix - the matrix to compare this matrix to
+         * 
+         * @return true if the matrices are equal
+         */
+        equals(matrix: Matrix): boolean
+
+        /** 
+         * @return a string representation of this transform
+         */
+        toString(): string
+
+        /** 
+         * Resets the matrix by setting its values to the ones of the identity
+         * matrix that results in no transformation.
+         */
+        reset(): void
+
+        /** 
+         * Attempts to apply the matrix to the content of item that it belongs to,
+         * meaning its transformation is baked into the item's content or children.
+         * 
+         * @param recursively - controls whether to apply transformations
+         * recursively on children
+         * 
+         * @return true if the matrix was applied
+         */
+        apply(recursively?: boolean): boolean
+
+        /** 
+         * Concatenates this matrix with a translate transformation.
+         * 
+         * @param point - the vector to translate by
+         * 
+         * @return this affine transform
+         */
+        translate(point: Point): Matrix
+
+        /** 
+         * Concatenates this matrix with a translate transformation.
+         * 
+         * @param dx - the distance to translate in the x direction
+         * @param dy - the distance to translate in the y direction
+         * 
+         * @return this affine transform
+         */
+        translate(dx: number, dy: number): Matrix
+
+        /** 
+         * Concatenates this matrix with a scaling transformation.
+         * 
+         * @param scale - the scaling factor
+         * @param center - the center for the scaling transformation
+         * 
+         * @return this affine transform
+         */
+        scale(scale: number, center?: Point): Matrix
+
+        /** 
+         * Concatenates this matrix with a scaling transformation.
+         * 
+         * @param hor - the horizontal scaling factor
+         * @param ver - the vertical scaling factor
+         * @param center - the center for the scaling transformation
+         * 
+         * @return this affine transform
+         */
+        scale(hor: number, ver: number, center?: Point): Matrix
+
+        /** 
+         * Concatenates this matrix with a rotation transformation around an
+         * anchor point.
+         * 
+         * @param angle - the angle of rotation measured in degrees
+         * @param center - the anchor point to rotate around
+         * 
+         * @return this affine transform
+         */
+        rotate(angle: number, center: Point): Matrix
+
+        /** 
+         * Concatenates this matrix with a rotation transformation around an
+         * anchor point.
+         * 
+         * @param angle - the angle of rotation measured in degrees
+         * @param x - the x coordinate of the anchor point
+         * @param y - the y coordinate of the anchor point
+         * 
+         * @return this affine transform
+         */
+        rotate(angle: number, x: number, y: number): Matrix
+
+        /** 
+         * Concatenates this matrix with a shear transformation.
+         * 
+         * @param shear - the shear factor in x and y direction
+         * @param center - the center for the shear transformation
+         * 
+         * @return this affine transform
+         */
+        shear(shear: Point, center?: Point): Matrix
+
+        /** 
+         * Applies this matrix to the specified Canvas Context.
+         */
+        applyToContext(ctx: CanvasRenderingContext2D): void
+
+        /** 
+         * Concatenates this matrix with a skew transformation.
+         * 
+         * @param skew - the skew angles in x and y direction in degrees
+         * @param center - the center for the skew transformation
+         * 
+         * @return this affine transform
+         */
+        skew(skew: Point, center?: Point): Matrix
+
+        /** 
+         * Concatenates this matrix with a skew transformation.
+         * 
+         * @param hor - the horizontal skew angle in degrees
+         * @param ver - the vertical skew angle in degrees
+         * @param center - the center for the skew transformation
+         * 
+         * @return this affine transform
+         */
+        skew(hor: number, ver: number, center?: Point): Matrix
+
+        /** 
+         * Appends the specified matrix to this matrix. This is the equivalent of
+         * multiplying `(this matrix) * (specified matrix)`.
+         * 
+         * @param matrix - the matrix to append
+         * 
+         * @return this matrix, modified
+         */
+        append(matrix: Matrix): Matrix
+
+        /** 
+         * Prepends the specified matrix to this matrix. This is the equivalent of
+         * multiplying `(specified matrix) * (this matrix)`.
+         * 
+         * @param matrix - the matrix to prepend
+         * 
+         * @return this matrix, modified
+         */
+        prepend(matrix: Matrix): Matrix
+
+        /** 
+         * Returns a new matrix as the result of appending the specified matrix to
+         * this matrix. This is the equivalent of multiplying
+         * `(this matrix) * (specified matrix)`.
+         * 
+         * @param matrix - the matrix to append
+         * 
+         * @return the newly created matrix
+         */
+        appended(matrix: Matrix): Matrix
+
+        /** 
+         * Returns a new matrix as the result of prepending the specified matrix
+         * to this matrix. This is the equivalent of multiplying
+         * `(specified matrix) * (this matrix)`.
+         * 
+         * @param matrix - the matrix to prepend
+         * 
+         * @return the newly created matrix
+         */
+        prepended(matrix: Matrix): Matrix
+
+        /** 
+         * Inverts the matrix, causing it to perform the opposite transformation.
+         * If the matrix is not invertible (in which case {@link #isSingular}
+         * returns true), `null` is returned.
+         * 
+         * @return this matrix, or `null`, if the matrix is singular.
+         */
+        invert(): Matrix
+
+        /** 
+         * Creates a new matrix that is the inversion of this matrix, causing it to
+         * perform the opposite transformation. If the matrix is not invertible (in
+         * which case {@link #isSingular} returns true), `null` is returned.
+         * 
+         * @return this matrix, or `null`, if the matrix is singular.
+         */
+        inverted(): Matrix
+
+        /** 
+         * @return whether this matrix is the identity matrix
+         */
+        isIdentity(): boolean
+
+        /** 
+         * Checks whether the matrix is invertible. A matrix is not invertible if
+         * the determinant is 0 or any value is infinite or NaN.
+         * 
+         * @return whether the matrix is invertible
+         */
+        isInvertible(): boolean
+
+        /** 
+         * Checks whether the matrix is singular or not. Singular matrices cannot be
+         * inverted.
+         * 
+         * @return whether the matrix is singular
+         */
+        isSingular(): boolean
+
+        /** 
+         * Transforms a point and returns the result.
+         * 
+         * @param point - the point to be transformed
+         * 
+         * @return the transformed point
+         */
+        transform(point: Point): Point
+
+        /** 
+         * Transforms an array of coordinates by this matrix and stores the results
+         * into the destination array, which is also returned.
+         * 
+         * @param src - the array containing the source points
+         * as x, y value pairs
+         * @param dst - the array into which to store the transformed
+         * point pairs
+         * @param count - the number of points to transform
+         * 
+         * @return the dst array, containing the transformed coordinates
+         */
+        transform(src: number[], dst: number[], count: number): number[]
+
+        /** 
+         * Inverse transforms a point and returns the result.
+         * 
+         * @param point - the point to be transformed
+         */
+        inverseTransform(point: Point): Point
+
+        /** 
+         * Decomposes the affine transformation described by this matrix into
+         * `scaling`, `rotation` and `skewing`, and returns an object with
+         * these properties.
+         * 
+         * @return the decomposed matrix
+         */
+        decompose(): object
+
+        /** 
+         * Concatenates this matrix with a shear transformation.
+         * 
+         * @param hor - the horizontal shear factor
+         * @param ver - the vertical shear factor
+         * @param center - the center for the shear transformation
+         * 
+         * @return this affine transform
+         */
+        shear(hor: number, ver: number, center?: Point): Matrix
+
+    }
+
+    /** 
+     * The MouseEvent object is received by the {@link Item}'s mouse event
+     * handlers {@link Item#onMouseDown}, {@link Item#onMouseDrag},
+     * {@link Item#onMouseMove}, {@link Item#onMouseUp}, {@link Item#onClick},
+     * {@link Item#onDoubleClick}, {@link Item#onMouseEnter} and
+     * {@link Item#onMouseLeave}. The MouseEvent object is the only parameter passed
+     * to these functions and contains information about the mouse event.
+     */
+    class MouseEvent extends Event {
+        /** 
+         * The type of mouse event.
+         */
+        type: string
+
+        /** 
+         * The position of the mouse in project coordinates when the event was
+         * fired.
+         */
+        point: Point
+
+        /** 
+         * The item that dispatched the event. It is different from
+         * {@link #currentTarget} when the event handler is called during
+         * the bubbling phase of the event.
+         */
+        target: Item
+
+        /** 
+         * The current target for the event, as the event traverses the scene graph.
+         * It always refers to the element the event handler has been attached to as
+         * opposed to {@link #target} which identifies the element on
+         * which the event occurred.
+         */
+        currentTarget: Item
+
+        
+        delta: Point
+
+
+        /** 
+         * @return a string representation of the mouse event
+         */
+        toString(): string
+
+    }
+
+    /** 
+     * The `PaperScope` class represents the scope associated with a Paper
+     *     context. When working with PaperScript, these scopes are automatically
+     *     created for us, and through clever scoping the properties and methods of
+     *     the active scope seem to become part of the global scope.
+     * 
+     * When working with normal JavaScript code, `PaperScope` objects need to be
+     * manually created and handled.
+     * 
+     * Paper classes can only be accessed through `PaperScope` objects. Thus in
+     * PaperScript they are global, while in JavaScript, they are available on the
+     * global {@link paper} object. For JavaScript you can use {@link
+     * PaperScope#install(scope) } to install the Paper classes and objects on the
+     * global scope. Note that when working with more than one scope, this still
+     * works for classes, but not for objects like {@link PaperScope#project}, since
+     * they are not updated in the injected scope if scopes are switched.
+     * 
+     * The global {@link paper} object is simply a reference to the currently active
+     * `PaperScope`.
+     */
+    class PaperScope  {
+        /** 
+         * The version of Paper.js, as a string.
+         */
+        version: string
+
+        /** 
+         * Gives access to paper's configurable settings.
+         * 
+         * @option [settings.insertItems=true] {Boolean} controls whether newly
+         *     created items are automatically inserted into the scene graph, by
+         *     adding them to {@link Project#activeLayer}
+         * @option [settings.applyMatrix=true] {Boolean} controls what value newly
+         *     created items have their {@link Item#applyMatrix} property set to
+         *     (Note that not all items can set this to `false`)
+         * @option [settings.handleSize=4] {Number} the size of the curve handles
+         *     when drawing selections
+         * @option [settings.hitTolerance=0] {Number} the default tolerance for hit-
+         *     tests, when no value is specified
+         */
+        settings: object
+
+        /** 
+         * The currently active project.
+         */
+        project: Project
+
+        /** 
+         * The list of all open projects within the current Paper.js context.
+         */
+        projects: Project[]
+
+        /** 
+         * The reference to the active project's view.
+         */
+        readonly view: View
+
+        /** 
+         * The reference to the active tool.
+         */
+        tool: Tool
+
+        /** 
+         * The list of available tools.
+         */
+        tools: Tool[]
+
+
+        /** 
+         * Creates a PaperScope object.
+         */
+        constructor()
+
+        /** 
+         * Compiles the PaperScript code into a compiled function and executes it.
+         * The compiled function receives all properties of this {@link PaperScope}
+         * as arguments, to emulate a global scope with unaffected performance. It
+         * also installs global view and tool handlers automatically on the
+         * respective objects.
+         * 
+         * @option options.url {String} the url of the source, for source-map
+         *     debugging
+         * @option options.source {String} the source to be used for the source-
+         *     mapping, in case the code that's passed in has already been mingled.
+         * 
+         * @param code - the PaperScript code
+         * @param option - the compilation options
+         */
+        execute(code: string, option?: object): void
+
+        /** 
+         * Injects the paper scope into any other given scope. Can be used for
+         * example to inject the currently active PaperScope into the window's
+         * global scope, to emulate PaperScript-style globally accessible Paper
+         * classes and objects.
+         * 
+         * <b>Please note:</b> Using this method may override native constructors
+         * (e.g. Path). This may cause problems when using Paper.js in conjunction
+         * with other libraries that rely on these constructors. Keep the library
+         * scoped if you encounter issues caused by this.
+         */
+        install(scope: any): void
+
+        /** 
+         * Sets up an empty project for us. If a canvas is provided, it also creates
+         * a {@link View} for it, both linked to this scope.
+         * 
+         * @param element - the HTML canvas element
+         * this scope should be associated with, or an ID string by which to find
+         * the element, or the size of the canvas to be created for usage in a web
+         * worker.
+         */
+        setup(element: HTMLCanvasElement | string | Size): void
+
+        /** 
+         * Activates this PaperScope, so all newly created items will be placed
+         * in its active project.
+         */
+        activate(): void
+
+        /** 
+         * Retrieves a PaperScope object with the given scope id.
+         */
+        static get(id: any): void
+
+    }
+
+    
+    class PaperScript  {
+
+        /** 
+         * Compiles PaperScript code into JavaScript code.
+         * 
+         * @option options.url {String} the url of the source, for source-map
+         *     generation
+         * @option options.source {String} the source to be used for the source-
+         *     mapping, in case the code that's passed in has already been mingled.
+         * 
+         * @param code - the PaperScript code
+         * @param option - the compilation options
+         * 
+         * @return an object holding the compiled PaperScript translated
+         *     into JavaScript code along with source-maps and other information.
+         */
+        static compile(code: string, option?: object): object
+
+        /** 
+         * Compiles the PaperScript code into a compiled function and executes it.
+         * The compiled function receives all properties of the passed {@link
+         * PaperScope} as arguments, to emulate a global scope with unaffected
+         * performance. It also installs global view and tool handlers automatically
+         * on the respective objects.
+         * 
+         * @option options.url {String} the url of the source, for source-map
+         *     generation
+         * @option options.source {String} the source to be used for the source-
+         *     mapping, in case the code that's passed in has already been mingled.
+         * 
+         * @param code - the PaperScript code
+         * @param scope - the scope for which the code is executed
+         * @param option - the compilation options
+         * 
+         * @return the exports defined in the executed code
+         */
+        static execute(code: string, scope: PaperScope, option?: object): object
+
+        /** 
+         * Loads, compiles and executes PaperScript code in the HTML document. Note
+         * that this method is executed automatically for all scripts in the
+         * document through a window load event. You can optionally call it earlier
+         * (e.g. from a DOM ready event), or you can mark scripts to be ignored by
+         * setting the attribute `ignore="true"` or `data-paper-ignore="true"`, and
+         * call the `PaperScript.load(script)` method for each script separately
+         * when needed.
+         * 
+         * @param script - the script to load. If none is
+         *     provided, all scripts of the HTML document are iterated over and
+         *     loaded
+         * 
+         * @return the scope produced for the passed `script`, or
+         *     `undefined` of multiple scripts area loaded
+         */
+        static load(script?: HTMLScriptElement): PaperScope
+
+    }
+
+    /** 
+     * The path item represents a path in a Paper.js project.
+     */
+    class Path extends PathItem {
+        /** 
+         * The segments contained within the path.
+         */
+        segments: Segment[]
+
+        /** 
+         * The first Segment contained within the path.
+         */
+        readonly firstSegment: Segment
+
+        /** 
+         * The last Segment contained within the path.
+         */
+        readonly lastSegment: Segment
+
+        /** 
+         * The curves contained within the path.
+         */
+        readonly curves: Curve[]
+
+        /** 
+         * The first Curve contained within the path.
+         */
+        readonly firstCurve: Curve
+
+        /** 
+         * The last Curve contained within the path.
+         */
+        readonly lastCurve: Curve
+
+        /** 
+         * Specifies whether the path is closed. If it is closed, Paper.js connects
+         * the first and last segments.
+         */
+        closed: boolean
+
+        /** 
+         * The approximate length of the path.
+         */
+        readonly length: number
+
+        /** 
+         * The area that the path's geometry is covering. Self-intersecting paths
+         * can contain sub-areas that cancel each other out.
+         */
+        readonly area: number
+
+        /** 
+         * Specifies whether the path and all its segments are selected. Cannot be
+         * `true` on an empty path.
+         */
+        fullySelected: boolean
+
+
+        /** 
+         * Creates a new path item and places it at the top of the active layer.
+         * 
+         * @param segments - An array of segments (or points to be
+         * converted to segments) that will be added to the path
+         */
+        constructor(segments?: Segment[])
+
+        /** 
+         * Creates a new path item from SVG path-data and places it at the top of
+         * the active layer.
+         * 
+         * @param pathData - the SVG path-data that describes the geometry
+         * of this path
+         */
+        constructor(pathData: string)
+
+        /** 
+         * Creates a new path item from an object description and places it at the
+         * top of the active layer.
+         * 
+         * @param object - an object containing properties to be set on the
+         *     path
+         */
+        constructor(object: object)
+
+        /** 
+         * Adds an array of segments (or types that can be converted to segments)
+         * to the end of the {@link #segments} array.
+         * 
+         * @return an array of the added segments. These segments are
+         * not necessarily the same objects, e.g. if the segment to be added already
+         * belongs to another path
+         */
+        addSegments(segments: Segment[]): Segment[]
+
+        /** 
+         * Adds one or more segments to the end of the {@link #segments} array of
+         * this path.
+         * 
+         * @param segment - the segment or point to be added.
+         * 
+         * @return the added segment. This is not necessarily the same
+         * object, e.g. if the segment to be added already belongs to another path
+         */
+        add(segment: Segment | Point): Segment
+
+        /** 
+         * Inserts one or more segments at a given index in the list of this path's
+         * segments.
+         * 
+         * @param index - the index at which to insert the segment
+         * @param segment - the segment or point to be inserted.
+         * 
+         * @return the added segment. This is not necessarily the same
+         * object, e.g. if the segment to be added already belongs to another path
+         */
+        insert(index: number, segment: Segment | Point): Segment
+
+        /** 
+         * Inserts an array of segments at a given index in the path's
+         * {@link #segments} array.
+         * 
+         * @param index - the index at which to insert the segments
+         * @param segments - the segments to be inserted
+         * 
+         * @return an array of the added segments. These segments are
+         * not necessarily the same objects, e.g. if the segment to be added already
+         * belongs to another path
+         */
+        insertSegments(index: number, segments: Segment[]): Segment[]
+
+        /** 
+         * Removes the segment at the specified index of the path's
+         * {@link #segments} array.
+         * 
+         * @param index - the index of the segment to be removed
+         * 
+         * @return the removed segment
+         */
+        removeSegment(index: number): Segment
+
+        /** 
+         * Removes all segments from the path's {@link #segments} array.
+         * 
+         * @return an array containing the removed segments
+         */
+        removeSegments(): Segment[]
+
+        /** 
+         * Removes the segments from the specified `from` index to the `to` index
+         * from the path's {@link #segments} array.
+         * 
+         * @param from - the beginning index, inclusive
+         * @param to - the ending index, exclusive
+         * 
+         * @return an array containing the removed segments
+         */
+        removeSegments(from: number, to?: number): Segment[]
+
+        /** 
+         * Checks if any of the curves in the path have curve handles set.
+         * 
+         * @see Segment#hasHandles()
+         * @see Curve#hasHandles()
+         * 
+         * @return true if the path has curve handles set
+         */
+        hasHandles(): boolean
+
+        /** 
+         * Clears the path's handles by setting their coordinates to zero,
+         * turning the path into a polygon (or a polyline if it isn't closed).
+         */
+        clearHandles(): void
+
+        /** 
+         * Divides the path on the curve at the given offset or location into two
+         * curves, by inserting a new segment at the given location.
+         * 
+         * @see Curve#divideAt(location)
+         * 
+         * @param location - the offset or location on the
+         *     path at which to divide the existing curve by inserting a new segment
+         * 
+         * @return the newly inserted segment if the location is valid,
+         *     {code null} otherwise
+         */
+        divideAt(location: number | CurveLocation): Segment
+
+        /** 
+         * Splits the path at the given offset or location. After splitting, the
+         * path will be open. If the path was open already, splitting will result in
+         * two paths.
+         * 
+         * @param location - the offset or location at which to
+         *     split the path
+         * 
+         * @return the newly created path after splitting, if any
+         */
+        splitAt(location: number | CurveLocation): Path
+
+        /** 
+         * Joins the path with the other specified path, which will be removed in
+         * the process. They can be joined if the first or last segments of either
+         * path lie in the same location. Locations are optionally compare with a
+         * provide `tolerance` value.
+         * 
+         * If `null` or `this` is passed as the other path, the path will be joined
+         * with itself if the first and last segment are in the same location.
+         * 
+         * @param path - the path to join this path with; `null` or `this` to
+         *     join the path with itself
+         * @param tolerance - the tolerance with which to decide if two
+         *     segments are to be considered the same location when joining
+         */
+        join(path: Path, tolerance?: number): void
+
+        /** 
+         * Reduces the path by removing curves that have a length of 0,
+         * and unnecessary segments between two collinear flat curves.
+         * 
+         * @return the reduced path
+         */
+        reduce(options: any): Path
+
+        /** 
+         * Attempts to create a new shape item with same geometry as this path item,
+         * and inherits all settings from it, similar to {@link Item#clone}.
+         * 
+         * @see Shape#toPath(insert)
+         * 
+         * @param insert - specifies whether the new shape should be
+         * inserted into the scene graph. When set to `true`, it is inserted above
+         * the path item
+         * 
+         * @return the newly created shape item with the same geometry as
+         * this path item if it can be matched, `null` otherwise
+         */
+        toShape(insert?: boolean): Shape
+
+        /** 
+         * Returns the curve location of the specified point if it lies on the
+         * path, `null` otherwise.
+         * 
+         * @param point - the point on the path
+         * 
+         * @return the curve location of the specified point
+         */
+        getLocationOf(point: Point): CurveLocation
+
+        /** 
+         * Returns the length of the path from its beginning up to up to the
+         * specified point if it lies on the path, `null` otherwise.
+         * 
+         * @param point - the point on the path
+         * 
+         * @return the length of the path up to the specified point
+         */
+        getOffsetOf(point: Point): number
+
+        /** 
+         * Returns the curve location of the specified offset on the path.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the curve location at the specified offset
+         */
+        getLocationAt(offset: number): CurveLocation
+
+        /** 
+         * Calculates the point on the path at the given offset.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the point at the given offset
+         */
+        getPointAt(offset: number): Point
+
+        /** 
+         * Calculates the normalized tangent vector of the path at the given offset.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the normalized tangent vector at the given offset
+         */
+        getTangentAt(offset: number): Point
+
+        /** 
+         * Calculates the normal vector of the path at the given offset.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the normal vector at the given offset
+         */
+        getNormalAt(offset: number): Point
+
+        /** 
+         * Calculates the weighted tangent vector of the path at the given offset.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the weighted tangent vector at the given offset
+         */
+        getWeightedTangentAt(offset: number): Point
+
+        /** 
+         * Calculates the weighted normal vector of the path at the given offset.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the weighted normal vector at the given offset
+         */
+        getWeightedNormalAt(offset: number): Point
+
+        /** 
+         * Calculates the curvature of the path at the given offset. Curvatures
+         * indicate how sharply a path changes direction. A straight line has zero
+         * curvature, where as a circle has a constant curvature. The path's radius
+         * at the given offset is the reciprocal value of its curvature.
+         * 
+         * @param offset - the offset on the path, where `0` is at
+         * the beginning of the path and {@link Path#length} at the end
+         * 
+         * @return the normal vector at the given offset
+         */
+        getCurvatureAt(offset: number): number
+
+        /** 
+         * Calculates path offsets where the path is tangential to the provided
+         * tangent. Note that tangents at the start or end are included. Tangents at
+         * segment points are returned even if only one of their handles is
+         * collinear with the provided tangent.
+         * 
+         * @param tangent - the tangent to which the path must be tangential
+         * 
+         * @return path offsets where the path is tangential to the
+         * provided tangent
+         */
+        getOffsetsWithTangent(tangent: Point): number[]
+
+    }
+    namespace Path {
+
+        class Rectangle extends Path {
+            /** 
+             * Creates a rectangular path item, with optionally rounded corners.
+             * 
+             * @param rectangle - the rectangle object describing the
+             * geometry of the rectangular path to be created
+             * @param radius - the size of the rounded corners
+             */
+            constructor(rectangle: paper.Rectangle, radius?: Size)
+
+            /** 
+             * Creates a rectangular path item from a point and a size object.
+             * 
+             * @param point - the rectangle's top-left corner.
+             * @param size - the rectangle's size.
+             */
+            constructor(point: Point, size: Size)
+
+            /** 
+             * Creates a rectangular path item from the passed points. These do not
+             * necessarily need to be the top left and bottom right corners, the
+             * constructor figures out how to fit a rectangle between them.
+             * 
+             * @param from - the first point defining the rectangle
+             * @param to - the second point defining the rectangle
+             */
+            constructor(from: Point, to: Point)
+
+            /** 
+             * Creates a rectangular path item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Ellipse extends Path {
+            /** 
+             * Creates an elliptical path item.
+             * 
+             * @param rectangle - the rectangle circumscribing the ellipse
+             */
+            constructor(rectangle: paper.Rectangle)
+
+            /** 
+             * Creates an elliptical path item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Arc extends Path {
+            /** 
+             * Creates a circular arc path item.
+             * 
+             * @param from - the starting point of the circular arc
+             * @param through - the point the arc passes through
+             * @param to - the end point of the arc
+             */
+            constructor(from: Point, through: Point, to: Point)
+
+            /** 
+             * Creates an circular arc path item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class RegularPolygon extends Path {
+            /** 
+             * Creates a regular polygon shaped path item.
+             * 
+             * @param center - the center point of the polygon
+             * @param sides - the number of sides of the polygon
+             * @param radius - the radius of the polygon
+             */
+            constructor(center: Point, sides: number, radius: number)
+
+            /** 
+             * Creates a regular polygon shaped path item from the properties
+             * described by an object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Star extends Path {
+            /** 
+             * Creates a star shaped path item.
+             * 
+             * The largest of `radius1` and `radius2` will be the outer radius of
+             * the star. The smallest of radius1 and radius2 will be the inner
+             * radius.
+             * 
+             * @param center - the center point of the star
+             * @param points - the number of points of the star
+             */
+            constructor(center: Point, points: number, radius1: number, radius2: number)
+
+            /** 
+             * Creates a star shaped path item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Line extends Path {
+            /** 
+             * Creates a linear path item from two points describing a line.
+             * 
+             * @param from - the line's starting point
+             * @param to - the line's ending point
+             */
+            constructor(from: Point, to: Point)
+
+            /** 
+             * Creates a linear path item from the properties described by an object
+             * literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Circle extends Path {
+            /** 
+             * Creates a circular path item.
+             * 
+             * @param center - the center point of the circle
+             * @param radius - the radius of the circle
+             */
+            constructor(center: Point, radius: number)
+
+            /** 
+             * Creates a circular path item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     path's attributes
+             */
+            constructor(object: object)
+
+        }
+    }
+
+    /** 
+     * The PathItem class is the base for any items that describe paths and
+     *     offer standardised methods for drawing and path manipulation, such as
+     *     {@link Path} and {@link CompoundPath}.
+     */
+    class PathItem extends Item {
+        /** 
+         * Returns a point that is guaranteed to be inside the path.
+         */
+        readonly interiorPoint: Point
+
+        /** 
+         * Specifies whether the path as a whole is oriented clock-wise, by looking
+         * at the path's area.
+         * Note that self-intersecting paths and sub-paths of different orientation
+         * can result in areas that cancel each other out.
+         * 
+         * @see Path#area
+         * @see CompoundPath#area
+         */
+        clockwise: boolean
+
+        /** 
+         * The path's geometry, formatted as SVG style path data.
+         */
+        pathData: string
+
+
+        /** 
+         * Interpolates between the two specified path items and uses the result
+         * as the geometry for this path item. The number of children and
+         * segments in the two paths involved in the operation should be the same.
+         * 
+         * @param from - the path item defining the geometry when `factor`
+         *     is `0`
+         * @param to - the path item defining the geometry  when `factor`
+         *     is `1`
+         * @param factor - the interpolation coefficient, typically between
+         *     `0` and `1`, but extrapolation is possible too
+         */
+        interpolate(from: PathItem, to: PathItem, factor: number): void
+
+        /** 
+         * Unites the geometry of the specified path with this path's geometry
+         * and returns the result as a new path item.
+         * 
+         * @option [options.insert=true] {Boolean} whether the resulting item
+         *     should be inserted back into the scene graph, above both paths
+         *     involved in the operation
+         * 
+         * @param path - the path to unite with
+         * @param options - the boolean operation options
+         * 
+         * @return the resulting path item
+         */
+        unite(path: PathItem, options?: object): PathItem
+
+        /** 
+         * Subtracts the geometry of the specified path from this path's
+         * geometry and returns the result as a new path item.
+         * 
+         * @option [options.insert=true] {Boolean} whether the resulting item
+         *     should be inserted back into the scene graph, above both paths
+         *     involved in the operation
+         * @option [options.trace=true] {Boolean} whether the tracing method is
+         *     used, treating both paths as areas when determining which parts
+         *     of the paths are to be kept in the result, or whether the first
+         *     path is only to be split at intersections, removing the parts of
+         *     the curves that intersect with the area of the second path.
+         * 
+         * @param path - the path to subtract
+         * @param options - the boolean operation options
+         * 
+         * @return the resulting path item
+         */
+        subtract(path: PathItem, options?: object): PathItem
+
+        /** 
+         * Excludes the intersection of the geometry of the specified path with
+         * this path's geometry and returns the result as a new path item.
+         * 
+         * @option [options.insert=true] {Boolean} whether the resulting item
+         *     should be inserted back into the scene graph, above both paths
+         *     involved in the operation
+         * 
+         * @param path - the path to exclude the intersection of
+         * @param options - the boolean operation options
+         * 
+         * @return the resulting path item
+         */
+        exclude(path: PathItem, options?: object): PathItem
+
+        /** 
+         * Splits the geometry of this path along the geometry of the specified
+         * path returns the result as a new group item. This is equivalent to
+         * calling {@link #subtract} and {@link #intersect} and
+         * putting the results into a new group.
+         * 
+         * @option [options.insert=true] {Boolean} whether the resulting item
+         *     should be inserted back into the scene graph, above both paths
+         *     involved in the operation
+         * @option [options.trace=true] {Boolean} whether the tracing method is
+         *     used, treating both paths as areas when determining which parts
+         *     of the paths are to be kept in the result, or whether the first
+         *     path is only to be split at intersections.
+         * 
+         * @param path - the path to divide by
+         * @param options - the boolean operation options
+         * 
+         * @return the resulting path item
+         */
+        divide(path: PathItem, options?: object): PathItem
+
+        /** 
+         * Fixes the orientation of the sub-paths of a compound-path, assuming
+         * that non of its sub-paths intersect, by reorienting them so that they
+         * are of different winding direction than their containing paths,
+         * except for disjoint sub-paths, i.e. islands, which are oriented so
+         * that they have the same winding direction as the the biggest path.
+         * 
+         * @param nonZero - controls if the non-zero fill-rule
+         *     is to be applied, by counting the winding of each nested path and
+         *     discarding sub-paths that do not contribute to the final result
+         * @param clockwise - if provided, the orientation of the root
+         *     paths will be set to the orientation specified by `clockwise`,
+         *     otherwise the orientation of the largest root child is used.
+         * 
+         * @return a reference to the item itself, reoriented
+         */
+        reorient(nonZero?: boolean, clockwise?: boolean): PathItem
+
+        /** 
+         * Creates a path item from the given SVG path-data, determining if the
+         * data describes a plain path or a compound-path with multiple
+         * sub-paths.
+         * 
+         * @param pathData - the SVG path-data to parse
+         * 
+         * @return the newly created path item
+         */
+        static create(pathData: string): Path | CompoundPath
+
+        /** 
+         * Creates a path item from the given segments array, determining if the
+         * array describes a plain path or a compound-path with multiple
+         * sub-paths.
+         * 
+         * @param segments - the segments array to parse
+         * 
+         * @return the newly created path item
+         */
+        static create(segments: number[][]): Path | CompoundPath
+
+        /** 
+         * Creates a path item from the given object, determining if the
+         * contained information describes a plain path or a compound-path with
+         * multiple sub-paths.
+         * 
+         * @param object - an object containing the properties describing
+         *     the item to be created
+         * 
+         * @return the newly created path item
+         */
+        static create(object: object): Path | CompoundPath
+
+        /** 
+         * Returns all intersections between two {@link PathItem} items as an array
+         * of {@link CurveLocation} objects. {@link CompoundPath} items are also
+         * supported.
+         * 
+         * @see #getCrossings(path)
+         * 
+         * @param path - the other item to find the intersections with
+         * @param include - a callback function that can be used to
+         *     filter out undesired locations right while they are collected. When
+         *     defined, it shall return {@true to include a location}.
+         * 
+         * @return the locations of all intersection between the
+         *     paths
+         */
+        getIntersections(path: PathItem, include?: Function): CurveLocation[]
+
+        /** 
+         * Returns all crossings between two {@link PathItem} items as an array of
+         * {@link CurveLocation} objects. {@link CompoundPath} items are also
+         * supported. Crossings are intersections where the paths actually are
+         * crossing each other, as opposed to simply touching.
+         * 
+         * @see #getIntersections(path)
+         * 
+         * @param path - the other item to find the crossings with
+         * 
+         * @return the locations of all crossings between the
+         *     paths
+         */
+        getCrossings(path: PathItem): CurveLocation[]
+
+        /** 
+         * Returns the nearest location on the path item to the specified point.
+         * 
+         * @param point - the point for which we search the nearest location
+         * 
+         * @return the location on the path that's the closest to
+         * the specified point
+         */
+        getNearestLocation(point: Point): CurveLocation
+
+        /** 
+         * Returns the nearest point on the path item to the specified point.
+         * 
+         * @param point - the point for which we search the nearest point
+         * 
+         * @return the point on the path that's the closest to the specified
+         * point
+         */
+        getNearestPoint(point: Point): Point
+
+        /** 
+         * Reverses the orientation of the path item. When called on
+         * {@link CompoundPath} items, each of the nested paths is reversed. On
+         * {@link Path} items, the sequence of {@link Path#segments} is reversed.
+         */
+        reverse(): void
+
+        /** 
+         * Flattens the curves in path items to a sequence of straight lines, by
+         * subdividing them enough times until the specified maximum error is met.
+         * 
+         * @param flatness - the maximum error between the flattened
+         *     lines and the original curves
+         */
+        flatten(flatness?: number): void
+
+        /** 
+         * Smooths the path item without changing the amount of segments in the path
+         * or moving the segments' locations, by smoothing and adjusting the angle
+         * and length of the segments' handles based on the position and distance of
+         * neighboring segments.
+         * 
+         * Smoothing works both for open paths and closed paths, and can be applied
+         * to the full path, as well as a sub-range of it. If a range is defined
+         * using the `options.from` and `options.to` properties, only the curve
+         * handles inside that range are touched. If one or both limits of the range
+         * are specified in negative indices, the indices are wrapped around the end
+         * of the curve. That way, a smoothing range in a close path can even wrap
+         * around the connection between the last and the first segment.
+         * 
+         * Four different smoothing methods are available:
+         * 
+         * - `'continuous'` smooths the path item by adjusting its curve handles so
+         *     that the first and second derivatives of all involved curves are
+         *     continuous across their boundaries.
+         * 
+         *     This method tends to result in the smoothest results, but does not
+         *     allow for further parametrization of the handles.
+         * 
+         * - `'asymmetric'` is based on the same principle as `'continuous'` but
+         *     uses different factors so that the result is asymmetric. This used to
+         *     the only method available until v0.10.0, and is currently still the
+         *     default when no method is specified, for reasons of backward
+         *     compatibility. It will eventually be removed.
+         * 
+         * - `'catmull-rom'` uses the Catmull-Rom spline to smooth the segment.
+         * 
+         *     The optionally passed factor controls the knot parametrization of the
+         *     algorithm:
+         * 
+         *     - `0.0`: the standard, uniform Catmull-Rom spline
+         *     - `0.5`: the centripetal Catmull-Rom spline, guaranteeing no
+         *         self-intersections
+         *     - `1.0`: the chordal Catmull-Rom spline
+         * 
+         * - `'geometric'` use a simple heuristic and empiric geometric method to
+         *     smooth the segment's handles. The handles were weighted, meaning that
+         *     big differences in distances between the segments will lead to
+         *     probably undesired results.
+         * 
+         *     The optionally passed factor defines the tension parameter (`0...1`),
+         *     controlling the amount of smoothing as a factor by which to scale
+         *     each handle.
+         * 
+         * @see Segment#smooth([options])
+         * 
+         * @option [options.type='asymmetric'] {String} the type of smoothing
+         *     method: {@values 'continuous', 'asymmetric', 'catmull-rom',
+         *     'geometric'}
+         * @option options.factor {Number} the factor parameterizing the smoothing
+         *     method — default: `0.5` for `'catmull-rom'`, `0.4` for `'geometric'`
+         * @option options.from {Number|Segment|Curve} the segment or curve at which
+         *     to start smoothing, if not the full path shall be smoothed
+         *     (inclusive). This can either be a segment index, or a segment or
+         *     curve object that is part of the path. If the passed number is
+         *     negative, the index is wrapped around the end of the path.
+         * @option options.to {Number|Segment|Curve} the segment or curve to which
+         *     the handles of the path shall be processed (inclusive). This can
+         *     either be a segment index, or a segment or curve object that is part
+         *     of the path. If the passed number is negative, the index is wrapped
+         *     around the end of the path.
+         * 
+         * @param options - the smoothing options
+         */
+        smooth(options?: object): void
+
+        /** 
+         * Fits a sequence of as few curves as possible through the path's anchor
+         * points, ignoring the path items's curve-handles, with an allowed maximum
+         * error. When called on {@link CompoundPath} items, each of the nested
+         * paths is simplified. On {@link Path} items, the {@link Path#segments}
+         * array is processed and replaced by the resulting sequence of fitted
+         * curves.
+         * 
+         * This method can be used to process and simplify the point data received
+         * from a mouse or touch device.
+         * 
+         * @param tolerance - the allowed maximum error when fitting
+         *     the curves through the segment points
+         * 
+         * @return true if the method was capable of fitting curves
+         *     through the path's segment points
+         */
+        simplify(tolerance?: number): boolean
+
+        /** 
+         * Intersects the geometry of the specified path with this path's
+         * geometry and returns the result as a new path item.
+         * 
+         * @option [options.insert=true] {Boolean} whether the resulting item
+         *     should be inserted back into the scene graph, above both paths
+         *     involved in the operation
+         * @option [options.trace=true] {Boolean} whether the tracing method is
+         *     used, treating both paths as areas when determining which parts
+         *     of the paths are to be kept in the result, or whether the first
+         *     path is only to be split at intersections, keeping the parts of
+         *     the curves that intersect with the area of the second path.
+         * 
+         * @param path - the path to intersect with
+         * @param options - the boolean operation options
+         * 
+         * @return the resulting path item
+         */
+        intersect(path: PathItem, options?: object): PathItem
+
+        /** 
+         * Compares the geometry of two paths to see if they describe the same
+         * shape, detecting cases where paths start in different segments or even
+         * use different amounts of curves to describe the same shape, as long as
+         * their orientation is the same, and their segments and handles really
+         * result in the same visual appearance of curves.
+         * 
+         * @param path - the path to compare this path's geometry with
+         * 
+         * @return true if two paths describe the same shape
+         */
+        compare(path: PathItem): boolean
+
+        /** 
+         * On a normal empty {@link Path}, the point is simply added as the path's
+         * first segment. If called on a {@link CompoundPath}, a new {@link Path} is
+         * created as a child and the point is added as its first segment.
+         * 
+         * @param point - the point in which to start the path
+         */
+        moveTo(point: Point): void
+
+        /** 
+         * Adds a straight curve to the path, from the the last segment in the path
+         * to the specified point.
+         * 
+         * @param point - the destination point of the newly added straight
+         *     curve
+         */
+        lineTo(point: Point): void
+
+        /** 
+         * Adds an arc from the position of the last segment in the path, passing
+         * through the specified `through` point, to the specified `to` point, by
+         * adding one or more segments to the path.
+         * 
+         * @param through - the point where the arc should pass through
+         * @param to - the point where the arc should end
+         */
+        arcTo(through: Point, to: Point): void
+
+        /** 
+         * Adds an arc from the position of the last segment in the path to
+         * the specified point, by adding one or more segments to the path.
+         * 
+         * @param to - the point where the arc should end
+         * @param clockwise - specifies whether the arc should be
+         *     drawn in clockwise direction
+         */
+        arcTo(to: Point, clockwise?: boolean): void
+
+        /** 
+         * Adds a curve from the last segment in the path through the specified
+         * `through` point, to the specified destination point by adding one segment
+         * to the path.
+         * 
+         * @param through - the point through which the curve should pass
+         * @param to - the destination point of the newly added curve
+         * @param time - the curve-time parameter at which the
+         *     `through` point is to be located
+         */
+        curveTo(through: Point, to: Point, time?: number): void
+
+        /** 
+         * Adds a cubic bezier curve to the path, from the last segment to the
+         * specified destination point, with the curve itself defined by two
+         * specified handles.
+         * 
+         * @param handle1 - the location of the first handle of the newly
+         *     added curve in absolute coordinates, out of which the relative values
+         *     for {@link Segment#handleOut} of its first segment are calculated
+         * @param handle2 - the location of the second handle of the newly
+         *     added curve in absolute coordinates, out of which the relative values
+         *     for {@link Segment#handleIn} of its second segment are calculated
+         * @param to - the destination point of the newly added curve
+         */
+        cubicCurveTo(handle1: Point, handle2: Point, to: Point): void
+
+        /** 
+         * Adds a quadratic bezier curve to the path, from the last segment to the
+         * specified destination point, with the curve itself defined by the
+         * specified handle.
+         * 
+         * Note that Paper.js only stores cubic curves, so the handle is actually
+         * converted.
+         * 
+         * @param handle - the location of the handle of the newly added
+         *     quadratic curve in absolute coordinates, out of which the relative
+         *     values for {@link Segment#handleOut} of the resulting cubic curve's
+         *     first segment and {@link Segment#handleIn} of its second segment are
+         *     calculated
+         * @param to - the destination point of the newly added curve
+         */
+        quadraticCurveTo(handle: Point, to: Point): void
+
+        /** 
+         * Closes the path. When closed, Paper.js connects the first and last
+         * segment of the path with an additional curve. The difference to setting
+         * {@link Path#closed} to `true` is that this will also merge the first
+         * segment with the last if they lie in the same location.
+         * 
+         * @see Path#closed
+         */
+        closePath(): void
+
+        /** 
+         * If called on a {@link CompoundPath}, a new {@link Path} is created as a
+         * child and a point is added as its first segment relative to the position
+         * of the last segment of the current path.
+         */
+        moveBy(to: Point): void
+
+        /** 
+         * Adds a straight curve to the path, from the the last segment in the path
+         * to the `to` vector specified relatively to it.
+         * 
+         * @param point - the vector describing the destination of the newly
+         *     added straight curve
+         */
+        lineBy(point: Point): void
+
+        /** 
+         * Adds an arc from the position of the last segment in the path, passing
+         * through the specified `through` vector, to the specified `to` vector, all
+         * specified relatively to it by these given vectors, by adding one or more
+         * segments to the path.
+         * 
+         * @param through - the vector where the arc should pass through
+         * @param to - the vector where the arc should end
+         */
+        arcBy(through: Point, to: Point): void
+
+        /** 
+         * Adds an arc from the position of the last segment in the path to the `to`
+         * vector specified relatively to it, by adding one or more segments to the
+         * path.
+         * 
+         * @param to - the vector where the arc should end
+         * @param clockwise - specifies whether the arc should be
+         *     drawn in clockwise direction
+         */
+        arcBy(to: Point, clockwise?: boolean): void
+
+        /** 
+         * Adds a curve from the last segment in the path through the specified
+         * `through` vector, to the specified `to` vector, all specified relatively
+         * to it by these given vectors, by adding one segment to the path.
+         * 
+         * @param through - the vector through which the curve should pass
+         * @param to - the destination vector of the newly added curve
+         * @param time - the curve-time parameter at which the
+         *     `through` point is to be located
+         */
+        curveBy(through: Point, to: Point, time?: number): void
+
+        /** 
+         * Adds a cubic bezier curve to the path, from the last segment to the
+         * to the specified `to` vector, with the curve itself defined by two
+         * specified handles.
+         * 
+         * @param handle1 - the location of the first handle of the newly
+         *     added curve
+         * @param handle2 - the location of the second handle of the newly
+         *     added curve
+         * @param to - the destination point of the newly added curve
+         */
+        cubicCurveBy(handle1: Point, handle2: Point, to: Point): void
+
+        /** 
+         * Adds a quadratic bezier curve to the path, from the last segment to the
+         * specified destination point, with the curve itself defined by the
+         * specified handle.
+         * 
+         * Note that Paper.js only stores cubic curves, so the handle is actually
+         * converted.
+         * 
+         * @param handle - the handle of the newly added quadratic curve out
+         *     of which the values for {@link Segment#handleOut} of the resulting
+         *     cubic curve's first segment and {@link Segment#handleIn} of its
+         *     second segment are calculated
+         * @param to - the destination point of the newly added curve
+         */
+        quadraticCurveBy(handle: Point, to: Point): void
+
+    }
+
+    /** 
+     * The Point object represents a point in the two dimensional space
+     * of the Paper.js project. It is also used to represent two dimensional
+     * vector objects.
+     */
+    class Point  {
+        /** 
+         * The x coordinate of the point
+         */
+        x: number
+
+        /** 
+         * The y coordinate of the point
+         */
+        y: number
+
+        /** 
+         * The length of the vector that is represented by this point's coordinates.
+         * Each point can be interpreted as a vector that points from the origin (`x
+         * = 0`, `y = 0`) to the point's location. Setting the length changes the
+         * location but keeps the vector's angle.
+         */
+        length: number
+
+        /** 
+         * The vector's angle in degrees, measured from the x-axis to the vector.
+         */
+        angle: number
+
+        /** 
+         * The vector's angle in radians, measured from the x-axis to the vector.
+         */
+        angleInRadians: number
+
+        /** 
+         * The quadrant of the {@link #angle} of the point.
+         * 
+         * Angles between 0 and 90 degrees are in quadrant `1`. Angles between 90
+         * and 180 degrees are in quadrant `2`, angles between 180 and 270 degrees
+         * are in quadrant `3` and angles between 270 and 360 degrees are in
+         * quadrant `4`.
+         */
+        readonly quadrant: number
+
+        /** 
+         * This property is only valid if the point is an anchor or handle point
+         * of a {@link Segment} or a {@link Curve}, or the position of an
+         * {@link Item}, as returned by {@link Item#position},
+         * {@link Segment#point}, {@link Segment#handleIn},
+         * {@link Segment#handleOut}, {@link Curve#point1}, {@link Curve#point2},
+         * {@link Curve#handle1}, {@link Curve#handle2}.
+         * 
+         * In those cases, it returns {@true if it the point is selected}.
+         * 
+         * Paper.js renders selected points on top of your project. This is very
+         * useful when debugging.
+         */
+        selected: boolean
+
+
+        /** 
+         * Creates a Point object with the given x and y coordinates.
+         * 
+         * @param x - the x coordinate
+         * @param y - the y coordinate
+         */
+        constructor(x: number, y: number)
+
+        /** 
+         * Creates a Point object using the width and height values of the given
+         * Size object.
+         */
+        constructor(size: Size)
+
+        /** 
+         * Creates a Point object using the coordinates of the given Point object.
+         */
+        constructor(point: Point)
+
+        /** 
+         * Creates a Point object using the numbers in the given array as
+         * coordinates.
+         */
+        constructor(array: any[])
+
+        /** 
+         * Creates a Point object using the properties in the given object.
+         * 
+         * @param object - the object describing the point's properties
+         */
+        constructor(object: object)
+
+        /** 
+         * Sets the point to the passed values. Note that any sequence of parameters
+         * that is supported by the various {@link Point} constructors also work
+         * for calls of `set()`.
+         */
+        set(...value: any[]): Point
+
+        /** 
+         * Checks whether the coordinates of the point are equal to that of the
+         * supplied point.
+         * 
+         * @return true if the points are equal
+         */
+        equals(point: Point): boolean
+
+        /** 
+         * Returns a copy of the point.
+         * 
+         * @return the cloned point
+         */
+        clone(): Point
+
+        /** 
+         * @return a string representation of the point
+         */
+        toString(): string
+
+        /** 
+         * Returns the smaller angle between two vectors. The angle is unsigned, no
+         * information about rotational direction is given.
+         * 
+         * @return the angle in degrees
+         */
+        getAngle(point: Point): number
+
+        /** 
+         * Returns the smaller angle between two vectors in radians. The angle is
+         * unsigned, no information about rotational direction is given.
+         * 
+         * @return the angle in radians
+         */
+        getAngleInRadians(point: Point): number
+
+        /** 
+         * Returns the angle between two vectors. The angle is directional and
+         * signed, giving information about the rotational direction.
+         * 
+         * Read more about angle units and orientation in the description of the
+         * {@link #angle} property.
+         * 
+         * @return the angle between the two vectors
+         */
+        getDirectedAngle(point: Point): number
+
+        /** 
+         * Returns the distance between the point and another point.
+         * 
+         * @param squared - Controls whether the distance should
+         * remain squared, or its square root should be calculated
+         */
+        getDistance(point: Point, squared?: boolean): number
+
+        /** 
+         * Normalize modifies the {@link #length} of the vector to `1` without
+         * changing its angle and returns it as a new point. The optional `length`
+         * parameter defines the length to normalize to. The object itself is not
+         * modified!
+         * 
+         * @param length - The length of the normalized vector
+         * 
+         * @return the normalized vector of the vector that is represented
+         *     by this point's coordinates
+         */
+        normalize(length?: number): Point
+
+        /** 
+         * Rotates the point by the given angle around an optional center point.
+         * The object itself is not modified.
+         * 
+         * Read more about angle units and orientation in the description of the
+         * {@link #angle} property.
+         * 
+         * @param angle - the rotation angle
+         * @param center - the center point of the rotation
+         * 
+         * @return the rotated point
+         */
+        rotate(angle: number, center: Point): Point
+
+        /** 
+         * Transforms the point by the matrix as a new point. The object itself is
+         * not modified!
+         * 
+         * @return the transformed point
+         */
+        transform(matrix: Matrix): Point
+
+        /** 
+         * Returns the addition of the supplied value to both coordinates of
+         * the point as a new point.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to add
+         * 
+         * @return the addition of the point and the value as a new point
+         */
+        add(number: number): Point
+
+        /** 
+         * Returns the addition of the supplied point to the point as a new
+         * point.
+         * The object itself is not modified!
+         * 
+         * @param point - the point to add
+         * 
+         * @return the addition of the two points as a new point
+         */
+        add(point: Point): Point
+
+        /** 
+         * Returns the subtraction of the supplied value to both coordinates of
+         * the point as a new point.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to subtract
+         * 
+         * @return the subtraction of the point and the value as a new point
+         */
+        subtract(number: number): Point
+
+        /** 
+         * Returns the subtraction of the supplied point to the point as a new
+         * point.
+         * The object itself is not modified!
+         * 
+         * @param point - the point to subtract
+         * 
+         * @return the subtraction of the two points as a new point
+         */
+        subtract(point: Point): Point
+
+        /** 
+         * Returns the multiplication of the supplied value to both coordinates of
+         * the point as a new point.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to multiply by
+         * 
+         * @return the multiplication of the point and the value as a new
+         *     point
+         */
+        multiply(number: number): Point
+
+        /** 
+         * Returns a point object with random {@link #x} and {@link #y} values
+         * between `0` and `1`.
+         * 
+         * @return the newly created point object
+         */
+        static random(): Point
+
+        /** 
+         * Returns the division of the supplied value to both coordinates of
+         * the point as a new point.
+         * The object itself is not modified!
+         * 
+         * @param number - the number to divide by
+         * 
+         * @return the division of the point and the value as a new point
+         */
+        divide(number: number): Point
+
+        /** 
+         * Returns the division of the supplied point to the point as a new
+         * point.
+         * The object itself is not modified!
+         * 
+         * @param point - the point to divide by
+         * 
+         * @return the division of the two points as a new point
+         */
+        divide(point: Point): Point
+
+        /** 
+         * The modulo operator returns the integer remainders of dividing the point
+         * by the supplied value as a new point.
+         * 
+         * @return the integer remainders of dividing the point by the value
+         * as a new point
+         */
+        modulo(value: number): Point
+
+        /** 
+         * The modulo operator returns the integer remainders of dividing the point
+         * by the supplied value as a new point.
+         * 
+         * @return the integer remainders of dividing the points by each
+         * other as a new point
+         */
+        modulo(point: Point): Point
+
+        /** 
+         * Checks whether the point is inside the boundaries of the rectangle.
+         * 
+         * @param rect - the rectangle to check against
+         * 
+         * @return true if the point is inside the rectangle
+         */
+        isInside(rect: Rectangle): boolean
+
+        /** 
+         * Checks if the point is within a given distance of another point.
+         * 
+         * @param point - the point to check against
+         * @param tolerance - the maximum distance allowed
+         * 
+         * @return true if it is within the given distance
+         */
+        isClose(point: Point, tolerance: number): boolean
+
+        /** 
+         * Checks if the vector represented by this point is collinear (parallel) to
+         * another vector.
+         * 
+         * @param point - the vector to check against
+         * 
+         * @return true it is collinear
+         */
+        isCollinear(point: Point): boolean
+
+        /** 
+         * Checks if the vector represented by this point is orthogonal
+         * (perpendicular) to another vector.
+         * 
+         * @param point - the vector to check against
+         * 
+         * @return true it is orthogonal
+         */
+        isOrthogonal(point: Point): boolean
+
+        /** 
+         * Checks if this point has both the x and y coordinate set to 0.
+         * 
+         * @return true if both x and y are 0
+         */
+        isZero(): boolean
+
+        /** 
+         * Checks if this point has an undefined value for at least one of its
+         * coordinates.
+         * 
+         * @return true if either x or y are not a number
+         */
+        isNaN(): boolean
+
+        /** 
+         * Checks if the vector is within the specified quadrant. Note that if the
+         * vector lies on the boundary between two quadrants, `true` will be
+         * returned for both quadrants.
+         * 
+         * @see #quadrant
+         * 
+         * @param quadrant - the quadrant to check against
+         * 
+         * @return true if either x or y are not a number
+         */
+        isInQuadrant(quadrant: number): boolean
+
+        /** 
+         * Returns the dot product of the point and another point.
+         * 
+         * @return the dot product of the two points
+         */
+        dot(point: Point): number
+
+        /** 
+         * Returns the cross product of the point and another point.
+         * 
+         * @return the cross product of the two points
+         */
+        cross(point: Point): number
+
+        /** 
+         * Returns the projection of the point onto another point.
+         * Both points are interpreted as vectors.
+         * 
+         * @return the projection of the point onto another point
+         */
+        project(point: Point): Point
+
+        /** 
+         * Returns a new point with rounded {@link #x} and {@link #y} values. The
+         * object itself is not modified!
+         */
+        round(): Point
+
+        /** 
+         * Returns a new point with the nearest greater non-fractional values to the
+         * specified {@link #x} and {@link #y} values. The object itself is not
+         * modified!
+         */
+        ceil(): Point
+
+        /** 
+         * Returns a new point with the nearest smaller non-fractional values to the
+         * specified {@link #x} and {@link #y} values. The object itself is not
+         * modified!
+         */
+        floor(): Point
+
+        /** 
+         * Returns a new point with the absolute values of the specified {@link #x}
+         * and {@link #y} values. The object itself is not modified!
+         */
+        abs(): Point
+
+        /** 
+         * Returns a new point object with the smallest {@link #x} and
+         * {@link #y} of the supplied points.
+         * 
+         * @return the newly created point object
+         */
+        static min(point1: Point, point2: Point): Point
+
+        /** 
+         * Returns a new point object with the largest {@link #x} and
+         * {@link #y} of the supplied points.
+         * 
+         * @return the newly created point object
+         */
+        static max(point1: Point, point2: Point): Point
+
+        /** 
+         * Returns the multiplication of the supplied point to the point as a new
+         * point.
+         * The object itself is not modified!
+         * 
+         * @param point - the point to multiply by
+         * 
+         * @return the multiplication of the two points as a new point
+         */
+        multiply(point: Point): Point
+
+    }
+
+    /** 
+     * A PointText item represents a piece of typography in your Paper.js
+     * project which starts from a certain point and extends by the amount of
+     * characters contained in it.
+     */
+    class PointText extends TextItem {
+        /** 
+         * The PointText's anchor point
+         */
+        point: Point
+
+
+        /** 
+         * Creates a point text item
+         * 
+         * @param point - the position where the text will start
+         */
+        constructor(point: Point)
+
+        /** 
+         * Creates a point text item from the properties described by an object
+         * literal.
+         * 
+         * @param object - an object containing properties describing the
+         *     path's attributes
+         */
+        constructor(object: object)
+
+    }
+
+    /** 
+     * A Project object in Paper.js is what usually is referred to as the
+     * document: The top level object that holds all the items contained in the
+     * scene graph. As the term document is already taken in the browser context,
+     * it is called Project.
+     * 
+     * Projects allow the manipulation of the styles that are applied to all newly
+     * created items, give access to the selected items, and will in future versions
+     * offer ways to query for items in the scene graph defining specific
+     * requirements, and means to persist and load from different formats, such as
+     * SVG and PDF.
+     * 
+     * The currently active project can be accessed through the
+     * {@link PaperScope#project} variable.
+     * 
+     * An array of all open projects is accessible through the
+     * {@link PaperScope#projects} variable.
+     */
+    class Project  {
+        /** 
+         * The reference to the project's view.
+         */
+        readonly view: View
+
+        /** 
+         * The currently active path style. All selected items and newly
+         * created items will be styled with this style.
+         */
+        currentStyle: Style
+
+        /** 
+         * The index of the project in the {@link PaperScope#projects} list.
+         */
+        readonly index: number
+
+        /** 
+         * The layers contained within the project.
+         */
+        readonly layers: Layer[]
+
+        /** 
+         * The layer which is currently active. New items will be created on this
+         * layer by default.
+         */
+        readonly activeLayer: Layer
+
+        /** 
+         * The symbol definitions shared by all symbol items contained place ind
+         * project.
+         */
+        readonly symbolDefinitions: SymbolDefinition[]
+
+        /** 
+         * The selected items contained within the project.
+         */
+        readonly selectedItems: Item[]
+
+
+        /** 
+         * Creates a Paper.js project containing one empty {@link Layer}, referenced
+         * by {@link Project#activeLayer}.
+         * 
+         * Note that when working with PaperScript, a project is automatically
+         * created for us and the {@link PaperScope#project} variable points to it.
+         * 
+         * @param element - the HTML canvas element
+         * that should be used as the element for the view, or an ID string by which
+         * to find the element, or the size of the canvas to be created for usage in
+         * a web worker.
+         */
+        constructor(element: HTMLCanvasElement | string | Size)
+
+        /** 
+         * Imports the provided external SVG file, converts it into Paper.js items
+         * and adds them to the active layer of this project.
+         * Note that the project is not cleared first. You can call
+         * {@link Project#clear} to do so.
+         * 
+         * @param svg - the URL of the SVG file to fetch.
+         * @param onLoad - the callback function to call once the SVG
+         *     content is loaded from the given URL receiving two arguments: the
+         *     converted `item` and the original `svg` data as a string. Only
+         *     required when loading from external files.
+         * 
+         * @return the newly created Paper.js item containing the converted
+         *     SVG content
+         */
+        importSVG(svg: SVGElement | string, onLoad: Function): Item
+
+        /** 
+         * Clears the project by removing all {@link Project#layers}.
+         */
+        clear(): void
+
+        /** 
+         * Checks whether the project has any content or not.
+         */
+        isEmpty(): boolean
+
+        /** 
+         * Removes this project from the {@link PaperScope#projects} list, and also
+         * removes its view, if one was defined.
+         */
+        remove(): void
+
+        /** 
+         * Selects all items in the project.
+         */
+        selectAll(): void
+
+        /** 
+         * Deselects all selected items in the project.
+         */
+        deselectAll(): void
+
+        /** 
+         * Adds the specified layer at the end of the this project's {@link #layers}
+         * list.
+         * 
+         * @param layer - the layer to be added to the project
+         * 
+         * @return the added layer, or `null` if adding was not possible
+         */
+        addLayer(layer: Layer): Layer
+
+        /** 
+         * Inserts the specified layer at the specified index in this project's
+         * {@link #layers} list.
+         * 
+         * @param index - the index at which to insert the layer
+         * @param layer - the layer to be inserted in the project
+         * 
+         * @return the added layer, or `null` if adding was not possible
+         */
+        insertLayer(index: number, layer: Layer): Layer
+
+        /** 
+         * Activates this project, so all newly created items will be placed
+         * in it.
+         */
+        activate(): void
+
+        /** 
+         * Performs a hit-test on the item and its children (if it is a {@link
+         * Group} or {@link Layer}) at the location of the specified point,
+         * returning all found hits.
+         * 
+         * The options object allows you to control the specifics of the hit-
+         * test. See {@link #hitTest} for a list of all options.
+         * 
+         * @see #hitTest(point[, options]);
+         * 
+         * @param point - the point where the hit-test should be performed
+         * 
+         * @return hit result objects for all hits, describing what
+         *     exactly was hit or `null` if nothing was hit
+         */
+        hitTestAll(point: Point, options?: object): HitResult[]
+
+        /** 
+         * Fetch items contained within the project whose properties match the
+         * criteria in the specified object.
+         * 
+         * Extended matching of properties is possible by providing a comparator
+         * function or regular expression. Matching points, colors only work as a
+         * comparison of the full object, not partial matching (e.g. only providing
+         * the x- coordinate to match all points with that x-value). Partial
+         * matching does work for {@link Item#data}.
+         * 
+         * Matching items against a rectangular area is also possible, by setting
+         * either `options.inside` or `options.overlapping` to a rectangle
+         * describing the area in which the items either have to be fully or partly
+         * contained.
+         * 
+         * @see Item#matches(options)
+         * @see Item#getItems(options)
+         * 
+         * @option [options.recursive=true] {Boolean} whether to loop recursively
+         *     through all children, or stop at the current level
+         * @option options.match {Function} a match function to be called for each
+         *     item, allowing the definition of more flexible item checks that are
+         *     not bound to properties. If no other match properties are defined,
+         *     this function can also be passed instead of the `match` object
+         * @option options.class {Function} the constructor function of the item
+         *     type to match against
+         * @option options.inside {Rectangle} the rectangle in which the items need
+         *     to be fully contained
+         * @option options.overlapping {Rectangle} the rectangle with which the
+         *     items need to at least partly overlap
+         * 
+         * @param options - the criteria to match against
+         * 
+         * @return the list of matching items contained in the project
+         */
+        getItems(options: object | Function): Item[]
+
+        /** 
+         * Fetch the first item contained within the project whose properties
+         * match the criteria in the specified object.
+         * Extended matching is possible by providing a compare function or
+         * regular expression. Matching points, colors only work as a comparison
+         * of the full object, not partial matching (e.g. only providing the x-
+         * coordinate to match all points with that x-value). Partial matching
+         * does work for {@link Item#data}.
+         * 
+         * See {@link #getItems} for a selection of illustrated examples.
+         * 
+         * @param options - the criteria to match against
+         * 
+         * @return the first item in the project matching the given criteria
+         */
+        getItem(options: object | Function): Item
+
+        /** 
+         * Exports (serializes) the project with all its layers and child items to a
+         * JSON data object or string.
+         * 
+         * @option [options.asString=true] {Boolean} whether the JSON is returned as
+         *     a `Object` or a `String`
+         * @option [options.precision=5] {Number} the amount of fractional digits in
+         *     numbers used in JSON data
+         * 
+         * @param options - the serialization options
+         * 
+         * @return the exported JSON data
+         */
+        exportJSON(options?: object): string
+
+        /** 
+         * Imports (deserializes) the stored JSON data into the project.
+         * Note that the project is not cleared first. You can call
+         * {@link Project#clear} to do so.
+         * 
+         * @param json - the JSON data to import from
+         * 
+         * @return the imported item
+         */
+        importJSON(json: string): Item
+
+        /** 
+         * Exports the project with all its layers and child items as an SVG DOM,
+         * all contained in one top level SVG group node.
+         * 
+         * @option [options.bounds='view'] {String|Rectangle} the bounds of the area
+         *     to export, either as a string ({@values 'view', content'}), or a
+         *     {@link Rectangle} object: `'view'` uses the view bounds,
+         *     `'content'` uses the stroke bounds of all content
+         * @option [options.matrix=paper.view.matrix] {Matrix} the matrix with which
+         *     to transform the exported content: If `options.bounds` is set to
+         *     `'view'`, `paper.view.matrix` is used, for all other settings of
+         *     `options.bounds` the identity matrix is used.
+         * @option [options.asString=false] {Boolean} whether a SVG node or a
+         *     `String` is to be returned
+         * @option [options.precision=5] {Number} the amount of fractional digits in
+         *     numbers used in SVG data
+         * @option [options.matchShapes=false] {Boolean} whether path items should
+         *     tried to be converted to SVG shape items (rect, circle, ellipse,
+         *     line, polyline, polygon), if their geometries match
+         * @option [options.embedImages=true] {Boolean} whether raster images should
+         *     be embedded as base64 data inlined in the xlink:href attribute, or
+         *     kept as a link to their external URL.
+         * 
+         * @param options - the export options
+         * 
+         * @return the project converted to an SVG node or a
+         * `String` depending on `option.asString` value
+         */
+        exportSVG(options?: object): SVGElement | string
+
+        /** 
+         * Converts the provided SVG content into Paper.js items and adds them to
+         * the active layer of this project.
+         * Note that the project is not cleared first. You can call
+         * {@link Project#clear} to do so.
+         * 
+         * @option [options.expandShapes=false] {Boolean} whether imported shape
+         *     items should be expanded to path items
+         * @option options.onLoad {Function} the callback function to call once the
+         *     SVG content is loaded from the given URL receiving two arguments: the
+         *     converted `item` and the original `svg` data as a string. Only
+         *     required when loading from external resources.
+         * @option options.onError {Function} the callback function to call if an
+         *     error occurs during loading. Only required when loading from external
+         *     resources.
+         * @option [options.insert=true] {Boolean} whether the imported items should
+         *     be added to the project that `importSVG()` is called on
+         * @option [options.applyMatrix={@link PaperScope#settings}.applyMatrix]
+         *     {Boolean} whether the imported items should have their transformation
+         *     matrices applied to their contents or not
+         * 
+         * @param svg - the SVG content to import, either as a SVG
+         *     DOM node, a string containing SVG content, or a string describing the
+         *     URL of the SVG file to fetch.
+         * @param options - the import options
+         * 
+         * @return the newly created Paper.js item containing the converted
+         *     SVG content
+         */
+        importSVG(svg: SVGElement | string, options?: object): Item
+
+        /** 
+         * Performs a hit-test on the items contained within the project at the
+         * location of the specified point.
+         * 
+         * The options object allows you to control the specifics of the hit-test
+         * and may contain a combination of the following values:
+         * 
+         * @option [options.tolerance={@link PaperScope#settings}.hitTolerance]
+         *     {Number} the tolerance of the hit-test
+         * @option options.class {Function} only hit-test against a specific item
+         *     class, or any of its sub-classes, by providing the constructor
+         *     function against which an `instanceof` check is performed:
+         *     {@values  Group, Layer, Path, CompoundPath, Shape, Raster,
+         *     SymbolItem, PointText, ...}
+         * @option options.match {Function} a match function to be called for each
+         *     found hit result: Return `true` to return the result, `false` to keep
+         *     searching
+         * @option [options.fill=true] {Boolean} hit-test the fill of items
+         * @option [options.stroke=true] {Boolean} hit-test the stroke of path
+         *     items, taking into account the setting of stroke color and width
+         * @option [options.segments=true] {Boolean} hit-test for {@link
+         *     Segment#point} of {@link Path} items
+         * @option options.curves {Boolean} hit-test the curves of path items,
+         *     without taking the stroke color or width into account
+         * @option options.handles {Boolean} hit-test for the handles ({@link
+         *     Segment#handleIn} / {@link Segment#handleOut}) of path segments.
+         * @option options.ends {Boolean} only hit-test for the first or last
+         *     segment points of open path items
+         * @option options.position {Boolean} hit-test the {@link Item#position} of
+         *     of items, which depends on the setting of {@link Item#pivot}
+         * @option options.center {Boolean} hit-test the {@link Rectangle#center} of
+         *     the bounding rectangle of items ({@link Item#bounds})
+         * @option options.bounds {Boolean} hit-test the corners and side-centers of
+         *     the bounding rectangle of items ({@link Item#bounds})
+         * @option options.guides {Boolean} hit-test items that have {@link
+         *     Item#guide} set to `true`
+         * @option options.selected {Boolean} only hit selected items
+         * 
+         * @param point - the point where the hit-test should be performed
+         * 
+         * @return a hit result object that contains more information
+         *     about what exactly was hit or `null` if nothing was hit
+         */
+        hitTest(point: Point, options?: object): HitResult
+
+    }
+
+    /** 
+     * The Raster item represents an image in a Paper.js project.
+     */
+    class Raster extends Item {
+        /** 
+         * The size of the raster in pixels.
+         */
+        size: Size
+
+        /** 
+         * The width of the raster in pixels.
+         */
+        width: number
+
+        /** 
+         * The height of the raster in pixels.
+         */
+        height: number
+
+        /** 
+         * The loading state of the raster image.
+         */
+        readonly loaded: boolean
+
+        /** 
+         * The resolution of the raster at its current size, in PPI (pixels per
+         * inch).
+         */
+        readonly resolution: Size
+
+        /** 
+         * The HTMLImageElement or Canvas element of the raster, if one is
+         * associated.
+         * Note that for consistency, a {@link #onLoad} event will be triggered on
+         * the raster even if the image has already finished loading before, or if
+         * we are setting the raster to a canvas.
+         */
+        image: HTMLImageElement | HTMLCanvasElement
+
+        /** 
+         * The Canvas object of the raster. If the raster was created from an image,
+         * accessing its canvas causes the raster to try and create one and draw the
+         * image into it. Depending on security policies, this might fail, in which
+         * case `null` is returned instead.
+         */
+        canvas: HTMLCanvasElement
+
+        /** 
+         * The Canvas 2D drawing context of the raster.
+         */
+        context: CanvasRenderingContext2D
+
+        /** 
+         * The source of the raster, which can be set using a DOM Image, a Canvas,
+         * a data url, a string describing the URL to load the image from, or the
+         * ID of a DOM element to get the image from (either a DOM Image or a
+         * Canvas). Reading this property will return the url of the source image or
+         * a data-url.
+         * Note that for consistency, a {@link #onLoad} event will be triggered on
+         * the raster even if the image has already finished loading before.
+         */
+        source: HTMLImageElement | HTMLCanvasElement | string
+
+        /** 
+         * The crossOrigin value to be used when loading the image resource, in
+         * order to support CORS. Note that this needs to be set before setting the
+         * {@link #source} property in order to always work (e.g. when the image is
+         * cached in the browser).
+         */
+        crossOrigin: string
+
+        /** 
+         * Specifies if the raster should be smoothed when scaled up or if the
+         * pixels should be scaled up by repeating the nearest neighboring pixels.
+         */
+        smoothing: boolean
+
+        /** 
+         * The event handler function to be called when the underlying image has
+         * finished loading and is ready to be used. This is also triggered when
+         * the image is already loaded, or when a canvas is used instead of an
+         * image.
+         */
+        onLoad: Function
+
+        /** 
+         * The event handler function to be called when there is an error loading
+         * the underlying image.
+         */
+        onError: Function
+
+
+        /** 
+         * Creates a new raster item from the passed argument, and places it in the
+         * active layer. `object` can either be a DOM Image, a Canvas, or a string
+         * describing the URL to load the image from, or the ID of a DOM element to
+         * get the image from (either a DOM Image or a Canvas).
+         * 
+         * @param source - the source of
+         *     the raster
+         * @param position - the center position at which the raster item is
+         *     placed
+         */
+        constructor(source?: HTMLImageElement | HTMLCanvasElement | string, position?: Point)
+
+        
+        setImageData(data: ImageData, point: Point): void
+
+        /** 
+         * Extracts a part of the raster item's content as a new raster item, placed
+         * in exactly the same place as the original content.
+         * 
+         * @param rect - the boundaries of the sub raster in pixel
+         * coordinates
+         * 
+         * @return the sub raster as a newly created raster item
+         */
+        getSubRaster(rect: Rectangle): Raster
+
+        /** 
+         * Returns a Base 64 encoded `data:` URL representation of the raster.
+         */
+        toDataURL(): string
+
+        /** 
+         * Draws an image on the raster.
+         * 
+         * @param point - the offset of the image as a point in pixel
+         * coordinates
+         */
+        drawImage(image: HTMLImageElement | HTMLCanvasElement, point: Point): void
+
+        /** 
+         * Calculates the average color of the image within the given path,
+         * rectangle or point. This can be used for creating raster image
+         * effects.
+         * 
+         * @return the average color contained in the area covered by the
+         * specified path, rectangle or point
+         */
+        getAverageColor(object: Path | Rectangle | Point): Color
+
+        /** 
+         * Gets the color of a pixel in the raster.
+         * 
+         * @param x - the x offset of the pixel in pixel coordinates
+         * @param y - the y offset of the pixel in pixel coordinates
+         * 
+         * @return the color of the pixel
+         */
+        getPixel(x: number, y: number): Color
+
+        /** 
+         * Extracts a part of the Raster's content as a sub image, and returns it as
+         * a Canvas object.
+         * 
+         * @param rect - the boundaries of the sub image in pixel
+         * coordinates
+         * 
+         * @return the sub image as a Canvas object
+         */
+        getSubCanvas(rect: Rectangle): HTMLCanvasElement
+
+        /** 
+         * Sets the color of the specified pixel to the specified color.
+         * 
+         * @param x - the x offset of the pixel in pixel coordinates
+         * @param y - the y offset of the pixel in pixel coordinates
+         * @param color - the color that the pixel will be set to
+         */
+        setPixel(x: number, y: number, color: Color): void
+
+        /** 
+         * Sets the color of the specified pixel to the specified color.
+         * 
+         * @param point - the offset of the pixel as a point in pixel coordinates
+         * @param color - the color that the pixel will be set to
+         */
+        setPixel(point: Point, color: Color): void
+
+        /** 
+         * Clears the image, if it is backed by a canvas.
+         */
+        clear(): void
+
+        
+        createImageData(size: Size): ImageData
+
+        
+        getImageData(rect: Rectangle): ImageData
+
+        /** 
+         * Gets the color of a pixel in the raster.
+         * 
+         * @param point - the offset of the pixel as a point in pixel coordinates
+         * 
+         * @return the color of the pixel
+         */
+        getPixel(point: Point): Color
+
+    }
+
+    /** 
+     * A Rectangle specifies an area that is enclosed by it's top-left
+     * point (x, y), its width, and its height. It should not be confused with a
+     * rectangular path, it is not an item.
+     */
+    class Rectangle  {
+        /** 
+         * The x position of the rectangle.
+         */
+        x: number
+
+        /** 
+         * The y position of the rectangle.
+         */
+        y: number
+
+        /** 
+         * The width of the rectangle.
+         */
+        width: number
+
+        /** 
+         * The height of the rectangle.
+         */
+        height: number
+
+        /** 
+         * The top-left point of the rectangle
+         */
+        point: Point
+
+        /** 
+         * The size of the rectangle
+         */
+        size: Size
+
+        /** 
+         * The position of the left hand side of the rectangle. Note that this
+         * doesn't move the whole rectangle; the right hand side stays where it was.
+         */
+        left: number
+
+        /** 
+         * The top coordinate of the rectangle. Note that this doesn't move the
+         * whole rectangle: the bottom won't move.
+         */
+        top: number
+
+        /** 
+         * The position of the right hand side of the rectangle. Note that this
+         * doesn't move the whole rectangle; the left hand side stays where it was.
+         */
+        right: number
+
+        /** 
+         * The bottom coordinate of the rectangle. Note that this doesn't move the
+         * whole rectangle: the top won't move.
+         */
+        bottom: number
+
+        /** 
+         * The center point of the rectangle.
+         */
+        center: Point
+
+        /** 
+         * The top-left point of the rectangle.
+         */
+        topLeft: Point
+
+        /** 
+         * The top-right point of the rectangle.
+         */
+        topRight: Point
+
+        /** 
+         * The bottom-left point of the rectangle.
+         */
+        bottomLeft: Point
+
+        /** 
+         * The bottom-right point of the rectangle.
+         */
+        bottomRight: Point
+
+        /** 
+         * The left-center point of the rectangle.
+         */
+        leftCenter: Point
+
+        /** 
+         * The top-center point of the rectangle.
+         */
+        topCenter: Point
+
+        /** 
+         * The right-center point of the rectangle.
+         */
+        rightCenter: Point
+
+        /** 
+         * The bottom-center point of the rectangle.
+         */
+        bottomCenter: Point
+
+        /** 
+         * The area of the rectangle.
+         */
+        readonly area: number
+
+        /** 
+         * Specifies whether an item's bounds are to appear as selected.
+         * 
+         * Paper.js draws the bounds of items with selected bounds on top of
+         * your project. This is very useful when debugging.
+         */
+        selected: boolean
+
+
+        /** 
+         * Creates a Rectangle object.
+         * 
+         * @param point - the top-left point of the rectangle
+         * @param size - the size of the rectangle
+         */
+        constructor(point: Point, size: Size)
+
+        /** 
+         * Creates a rectangle object.
+         * 
+         * @param x - the left coordinate
+         * @param y - the top coordinate
+         */
+        constructor(x: number, y: number, width: number, height: number)
+
+        /** 
+         * Creates a rectangle object from the passed points. These do not
+         * necessarily need to be the top left and bottom right corners, the
+         * constructor figures out how to fit a rectangle between them.
+         * 
+         * @param from - the first point defining the rectangle
+         * @param to - the second point defining the rectangle
+         */
+        constructor(from: Point, to: Point)
+
+        /** 
+         * Creates a new rectangle object from the passed rectangle object.
+         */
+        constructor(rectangle: Rectangle)
+
+        /** 
+         * Creates a Rectangle object.
+         * 
+         * @param object - an object containing properties to be set on the
+         * rectangle
+         */
+        constructor(object: object)
+
+        /** 
+         * Sets the rectangle to the passed values. Note that any sequence of
+         * parameters that is supported by the various {@link Rectangle}
+         * constructors also work for calls of `set()`.
+         */
+        set(...value: any[]): Rectangle
+
+        /** 
+         * Returns a copy of the rectangle.
+         */
+        clone(): Rectangle
+
+        /** 
+         * Checks whether the coordinates and size of the rectangle are equal to
+         * that of the supplied rectangle.
+         * 
+         * @return true if the rectangles are equal
+         */
+        equals(rect: Rectangle): boolean
+
+        /** 
+         * @return a string representation of this rectangle
+         */
+        toString(): string
+
+        /** 
+         * @return true if the rectangle is empty
+         */
+        isEmpty(): boolean
+
+        /** 
+         * Returns a new rectangle scaled in horizontal direction by the specified
+         * `hor` amount and in vertical direction by the specified `ver` amount
+         * from its center.
+         * 
+         * @return the scaled rectangle
+         */
+        scale(hor: number, ver: number): Rectangle
+
+        /** 
+         * Tests if the interior of the rectangle entirely contains the specified
+         * rectangle.
+         * 
+         * @param rect - the specified rectangle
+         * 
+         * @return true if the rectangle entirely contains the specified
+         * rectangle
+         */
+        contains(rect: Rectangle): boolean
+
+        /** 
+         * Tests if the interior of this rectangle intersects the interior of
+         * another rectangle. Rectangles just touching each other are considered as
+         * non-intersecting, except if a `epsilon` value is specified by which this
+         * rectangle's dimensions are increased before comparing.
+         * 
+         * @param rect - the specified rectangle
+         * @param epsilon - the epsilon against which to compare the
+         *     rectangle's dimensions
+         * 
+         * @return true if the rectangle and the specified rectangle
+         *     intersect each other
+         */
+        intersects(rect: Rectangle, epsilon?: number): boolean
+
+        /** 
+         * Returns a new rectangle representing the intersection of this rectangle
+         * with the specified rectangle.
+         * 
+         * @param rect - the rectangle to be intersected with this
+         * rectangle
+         * 
+         * @return the largest rectangle contained in both the specified
+         * rectangle and in this rectangle
+         */
+        intersect(rect: Rectangle): Rectangle
+
+        /** 
+         * Returns a new rectangle representing the union of this rectangle with the
+         * specified rectangle.
+         * 
+         * @param rect - the rectangle to be combined with this rectangle
+         * 
+         * @return the smallest rectangle containing both the specified
+         * rectangle and this rectangle
+         */
+        unite(rect: Rectangle): Rectangle
+
+        /** 
+         * Adds a point to this rectangle. The resulting rectangle is the smallest
+         * rectangle that contains both the original rectangle and the specified
+         * point.
+         * 
+         * After adding a point, a call to {@link #contains} with the added
+         * point as an argument does not necessarily return `true`. The {@link
+         * Rectangle#contains(point)} method does not return `true` for points on
+         * the right or bottom edges of a rectangle. Therefore, if the added point
+         * falls on the left or bottom edge of the enlarged rectangle, {@link
+         * Rectangle#contains(point)} returns `false` for that point.
+         * 
+         * @return the smallest rectangle that contains both the
+         * original rectangle and the specified point
+         */
+        include(point: Point): Rectangle
+
+        /** 
+         * Returns a new rectangle expanded by the specified amount in horizontal
+         * and vertical directions.
+         * 
+         * @param amount - the amount to expand the rectangle in
+         * both directions
+         * 
+         * @return the expanded rectangle
+         */
+        expand(amount: number | Size | Point): Rectangle
+
+        /** 
+         * Returns a new rectangle expanded by the specified amounts in horizontal
+         * and vertical directions.
+         * 
+         * @param hor - the amount to expand the rectangle in horizontal
+         * direction
+         * @param ver - the amount to expand the rectangle in vertical
+         * direction
+         * 
+         * @return the expanded rectangle
+         */
+        expand(hor: number, ver: number): Rectangle
+
+        /** 
+         * Returns a new rectangle scaled by the specified amount from its center.
+         * 
+         * @return the scaled rectangle
+         */
+        scale(amount: number): Rectangle
+
+        /** 
+         * Tests if the specified point is inside the boundary of the rectangle.
+         * 
+         * @param point - the specified point
+         * 
+         * @return true if the point is inside the rectangle's boundary
+         */
+        contains(point: Point): boolean
+
+    }
+
+    /** 
+     * The Segment object represents the points of a path through which its
+     * {@link Curve} objects pass. The segments of a path can be accessed through
+     * its {@link Path#segments} array.
+     * 
+     * Each segment consists of an anchor point ({@link Segment#point}) and
+     * optionaly an incoming and an outgoing handle ({@link Segment#handleIn} and
+     * {@link Segment#handleOut}), describing the tangents of the two {@link Curve}
+     * objects that are connected by this segment.
+     */
+    class Segment  {
+        /** 
+         * The anchor point of the segment.
+         */
+        point: Point
+
+        /** 
+         * The handle point relative to the anchor point of the segment that
+         * describes the in tangent of the segment.
+         */
+        handleIn: Point
+
+        /** 
+         * The handle point relative to the anchor point of the segment that
+         * describes the out tangent of the segment.
+         */
+        handleOut: Point
+
+        /** 
+         * Specifies whether the segment is selected.
+         */
+        selected: boolean
+
+        /** 
+         * The index of the segment in the {@link Path#segments} array that the
+         * segment belongs to.
+         */
+        readonly index: number
+
+        /** 
+         * The path that the segment belongs to.
+         */
+        readonly path: Path
+
+        /** 
+         * The curve that the segment belongs to. For the last segment of an open
+         * path, the previous segment is returned.
+         */
+        readonly curve: Curve
+
+        /** 
+         * The curve location that describes this segment's position on the path.
+         */
+        readonly location: CurveLocation
+
+        /** 
+         * The next segment in the {@link Path#segments} array that the segment
+         * belongs to. If the segments belongs to a closed path, the first segment
+         * is returned for the last segment of the path.
+         */
+        readonly next: Segment
+
+        /** 
+         * The previous segment in the {@link Path#segments} array that the
+         * segment belongs to. If the segments belongs to a closed path, the last
+         * segment is returned for the first segment of the path.
+         */
+        readonly previous: Segment
+
+
+        /** 
+         * Creates a new Segment object.
+         * 
+         * @param point - the anchor point of the segment
+         * @param handleIn - the handle point relative to the
+         *     anchor point of the segment that describes the in tangent of the
+         *     segment
+         * @param handleOut - the handle point relative to the
+         *     anchor point of the segment that describes the out tangent of the
+         *     segment
+         */
+        constructor(point?: Point, handleIn?: Point, handleOut?: Point)
+
+        /** 
+         * Creates a new Segment object.
+         * 
+         * @param object - an object containing properties to be set on the
+         *     segment
+         */
+        constructor(object: object)
+
+        /** 
+         * Checks if the segment has any curve handles set.
+         * 
+         * @see Segment#handleIn
+         * @see Segment#handleOut
+         * @see Curve#hasHandles()
+         * @see Path#hasHandles()
+         * 
+         * @return true if the segment has handles set
+         */
+        hasHandles(): boolean
+
+        /** 
+         * Checks if the segment connects two curves smoothly, meaning that its two
+         * handles are collinear and segment does not form a corner.
+         * 
+         * @see Point#isCollinear()
+         * 
+         * @return true if the segment is smooth
+         */
+        isSmooth(): boolean
+
+        /** 
+         * Clears the segment's handles by setting their coordinates to zero,
+         * turning the segment into a corner.
+         */
+        clearHandles(): void
+
+        /** 
+         * Smooths the bezier curves that pass through this segment by taking into
+         * account the segment's position and distance to the neighboring segments
+         * and changing the direction and length of the segment's handles
+         * accordingly without moving the segment itself.
+         * 
+         * Two different smoothing methods are available:
+         * 
+         * - `'catmull-rom'` uses the Catmull-Rom spline to smooth the segment.
+         * 
+         *     The optionally passed factor controls the knot parametrization of the
+         *     algorithm:
+         * 
+         *     - `0.0`: the standard, uniform Catmull-Rom spline
+         *     - `0.5`: the centripetal Catmull-Rom spline, guaranteeing no
+         *         self-intersections
+         *     - `1.0`: the chordal Catmull-Rom spline
+         * 
+         * - `'geometric'` use a simple heuristic and empiric geometric method to
+         *     smooth the segment's handles. The handles were weighted, meaning that
+         *     big differences in distances between the segments will lead to
+         *     probably undesired results.
+         * 
+         *     The optionally passed factor defines the tension parameter (`0...1`),
+         *     controlling the amount of smoothing as a factor by which to scale
+         *     each handle.
+         * 
+         * @see PathItem#smooth([options])
+         * 
+         * @option [options.type='catmull-rom'] {String} the type of smoothing
+         *     method: {@values 'catmull-rom', 'geometric'}
+         * @option options.factor {Number} the factor parameterizing the smoothing
+         *     method — default: `0.5` for `'catmull-rom'`, `0.4` for `'geometric'`
+         * 
+         * @param options - the smoothing options
+         */
+        smooth(options?: object): void
+
+        /** 
+         * Checks if the this is the first segment in the {@link Path#segments}
+         * array.
+         * 
+         * @return true if this is the first segment
+         */
+        isFirst(): boolean
+
+        /** 
+         * Interpolates between the two specified segments and sets the point and
+         * handles of this segment accordingly.
+         * 
+         * @param from - the segment defining the geometry when `factor` is
+         *     `0`
+         * @param to - the segment defining the geometry when `factor` is
+         *     `1`
+         * @param factor - the interpolation coefficient, typically between
+         *     `0` and `1`, but extrapolation is possible too
+         */
+        interpolate(from: Segment, to: Segment, factor: number): void
+
+        /** 
+         * Reverses the {@link #handleIn} and {@link #handleOut} vectors of this
+         * segment, modifying the actual segment without creating a copy.
+         * 
+         * @return the reversed segment
+         */
+        reverse(): Segment
+
+        /** 
+         * Returns the reversed the segment, without modifying the segment itself.
+         * 
+         * @return the reversed segment
+         */
+        reversed(): Segment
+
+        /** 
+         * Removes the segment from the path that it belongs to.
+         * 
+         * @return true if the segment was removed
+         */
+        remove(): boolean
+
+        
+        clone(): Segment
+
+        /** 
+         * @return a string representation of the segment
+         */
+        toString(): string
+
+        /** 
+         * Transform the segment by the specified matrix.
+         * 
+         * @param matrix - the matrix to transform the segment by
+         */
+        transform(matrix: Matrix): void
+
+        /** 
+         * Checks if the this is the last segment in the {@link Path#segments}
+         * array.
+         * 
+         * @return true if this is the last segment
+         */
+        isLast(): boolean
+
+    }
+
+    
+    class Shape extends Item {
+        /** 
+         * The type of shape of the item as a string.
+         */
+        type: string
+
+        /** 
+         * The size of the shape.
+         */
+        size: Size
+
+        /** 
+         * The radius of the shape, as a number if it is a circle, or a size object
+         * for ellipses and rounded rectangles.
+         */
+        radius: number | Size
+
+
+        /** 
+         * Creates a new path item with same geometry as this shape item, and
+         * inherits all settings from it, similar to {@link Item#clone}.
+         * 
+         * @see Path#toShape(insert)
+         * 
+         * @param insert - specifies whether the new path should be
+         *     inserted into the scene graph. When set to `true`, it is inserted
+         *     above the shape item
+         * 
+         * @return the newly created path item with the same geometry as
+         *     this shape item
+         */
+        toPath(insert?: boolean): Path
+
+    }
+    namespace Shape {
+
+        class Circle extends Shape {
+            /** 
+             * Creates a circular shape item.
+             * 
+             * @param center - the center point of the circle
+             * @param radius - the radius of the circle
+             */
+            constructor(center: Point, radius: number)
+
+            /** 
+             * Creates a circular shape item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     shape's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Rectangle extends Shape {
+            /** 
+             * Creates a rectangular shape item, with optionally rounded corners.
+             * 
+             * @param rectangle - the rectangle object describing the
+             * geometry of the rectangular shape to be created
+             * @param radius - the size of the rounded corners
+             */
+            constructor(rectangle: paper.Rectangle, radius?: Size)
+
+            /** 
+             * Creates a rectangular shape item from a point and a size object.
+             * 
+             * @param point - the rectangle's top-left corner.
+             * @param size - the rectangle's size.
+             */
+            constructor(point: Point, size: Size)
+
+            /** 
+             * Creates a rectangular shape item from the passed points. These do not
+             * necessarily need to be the top left and bottom right corners, the
+             * constructor figures out how to fit a rectangle between them.
+             * 
+             * @param from - the first point defining the rectangle
+             * @param to - the second point defining the rectangle
+             */
+            constructor(from: Point, to: Point)
+
+            /** 
+             * Creates a rectangular shape item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     shape's attributes
+             */
+            constructor(object: object)
+
+        }
+
+        class Ellipse extends Shape {
+            /** 
+             * Creates an elliptical shape item.
+             * 
+             * @param rectangle - the rectangle circumscribing the ellipse
+             */
+            constructor(rectangle: paper.Rectangle)
+
+            /** 
+             * Creates an elliptical shape item from the properties described by an
+             * object literal.
+             * 
+             * @param object - an object containing properties describing the
+             *     shape's attributes
+             */
+            constructor(object: object)
+
+        }
+    }
+
+    /** 
+     * The Size object is used to describe the size or dimensions of
+     * something, through its {@link #width} and {@link #height} properties.
+     */
+    class Size  {
+        /** 
+         * The width of the size
+         */
+        width: number
+
+        /** 
+         * The height of the size
+         */
+        height: number
+
+
+        /** 
+         * Creates a Size object with the given width and height values.
+         * 
+         * @param width - the width
+         * @param height - the height
+         */
+        constructor(width: number, height: number)
+
+        /** 
+         * Creates a Size object using the coordinates of the given Size object.
+         */
+        constructor(size: Size)
+
+        /** 
+         * Creates a Size object using the {@link Point#x} and {@link Point#y}
+         * values of the given Point object.
+         */
+        constructor(point: Point)
+
+        /** 
+         * Creates a Size object using the numbers in the given array as
+         * dimensions.
+         */
+        constructor(array: any[])
+
+        /** 
+         * Creates a Size object using the properties in the given object.
+         */
+        constructor(object: object)
+
+        /** 
+         * Sets the size to the passed values. Note that any sequence of parameters
+         * that is supported by the various {@link Size} constructors also work
+         * for calls of `set()`.
+         */
+        set(...value: any[]): Size
+
+        /** 
+         * Checks whether the width and height of the size are equal to those of the
+         * supplied size.
+         * 
+         * @param size - the size to compare to
+         */
+        equals(size: Size): boolean
+
+        /** 
+         * Returns a copy of the size.
+         */
+        clone(): Size
+
+        /** 
+         * @return a string representation of the size
+         */
+        toString(): string
+
+        /** 
+         * Returns the addition of the supplied value to the width and height of the
+         * size as a new size. The object itself is not modified!
+         * 
+         * @param number - the number to add
+         * 
+         * @return the addition of the size and the value as a new size
+         */
+        add(number: number): Size
+
+        /** 
+         * Returns the addition of the width and height of the supplied size to the
+         * size as a new size. The object itself is not modified!
+         * 
+         * @param size - the size to add
+         * 
+         * @return the addition of the two sizes as a new size
+         */
+        add(size: Size): Size
+
+        /** 
+         * Returns the subtraction of the supplied value from the width and height
+         * of the size as a new size. The object itself is not modified!
+         * The object itself is not modified!
+         * 
+         * @param number - the number to subtract
+         * 
+         * @return the subtraction of the size and the value as a new size
+         */
+        subtract(number: number): Size
+
+        /** 
+         * Returns the subtraction of the width and height of the supplied size from
+         * the size as a new size. The object itself is not modified!
+         * 
+         * @param size - the size to subtract
+         * 
+         * @return the subtraction of the two sizes as a new size
+         */
+        subtract(size: Size): Size
+
+        /** 
+         * Returns the multiplication of the supplied value with the width and
+         * height of the size as a new size. The object itself is not modified!
+         * 
+         * @param number - the number to multiply by
+         * 
+         * @return the multiplication of the size and the value as a new size
+         */
+        multiply(number: number): Size
+
+        /** 
+         * Returns a size object with random {@link #width} and {@link #height}
+         * values between `0` and `1`.
+         * 
+         * @return the newly created size object
+         */
+        static random(): Size
+
+        /** 
+         * Returns the division of the supplied value by the width and height of the
+         * size as a new size. The object itself is not modified!
+         * 
+         * @param number - the number to divide by
+         * 
+         * @return the division of the size and the value as a new size
+         */
+        divide(number: number): Size
+
+        /** 
+         * Returns the division of the width and height of the supplied size by the
+         * size as a new size. The object itself is not modified!
+         * 
+         * @param size - the size to divide by
+         * 
+         * @return the division of the two sizes as a new size
+         */
+        divide(size: Size): Size
+
+        /** 
+         * The modulo operator returns the integer remainders of dividing the size
+         * by the supplied value as a new size.
+         * 
+         * @return the integer remainders of dividing the size by the value
+         * as a new size
+         */
+        modulo(value: number): Size
+
+        /** 
+         * The modulo operator returns the integer remainders of dividing the size
+         * by the supplied size as a new size.
+         * 
+         * @return the integer remainders of dividing the sizes by each
+         * other as a new size
+         */
+        modulo(size: Size): Size
+
+        /** 
+         * Checks if this size has both the width and height set to 0.
+         * 
+         * @return true if both width and height are 0
+         */
+        isZero(): boolean
+
+        /** 
+         * Checks if the width or the height of the size are NaN.
+         * 
+         * @return true if the width or height of the size are NaN
+         */
+        isNaN(): boolean
+
+        /** 
+         * Returns a new size with rounded {@link #width} and {@link #height}
+         * values. The object itself is not modified!
+         */
+        round(): Size
+
+        /** 
+         * Returns a new size with the nearest greater non-fractional values to the
+         * specified {@link #width} and {@link #height} values. The object itself is
+         * not modified!
+         */
+        ceil(): Size
+
+        /** 
+         * Returns a new size with the nearest smaller non-fractional values to the
+         * specified {@link #width} and {@link #height} values. The object itself is
+         * not modified!
+         */
+        floor(): Size
+
+        /** 
+         * Returns a new size with the absolute values of the specified
+         * {@link #width} and {@link #height} values. The object itself is not
+         * modified!
+         */
+        abs(): Size
+
+        /** 
+         * Returns a new size object with the smallest {@link #width} and
+         * {@link #height} of the supplied sizes.
+         * 
+         * @return the newly created size object
+         */
+        static min(size1: Size, size2: Size): Size
+
+        /** 
+         * Returns a new size object with the largest {@link #width} and
+         * {@link #height} of the supplied sizes.
+         * 
+         * @return the newly created size object
+         */
+        static max(size1: Size, size2: Size): Size
+
+        /** 
+         * Returns the multiplication of the width and height of the supplied size
+         * with the size as a new size. The object itself is not modified!
+         * 
+         * @param size - the size to multiply by
+         * 
+         * @return the multiplication of the two sizes as a new size
+         */
+        multiply(size: Size): Size
+
+    }
+
+    /** 
+     * Style is used for changing the visual styles of items
+     * contained within a Paper.js project and is returned by
+     * {@link Item#style} and {@link Project#currentStyle}.
+     * 
+     * All properties of Style are also reflected directly in {@link Item},
+     * i.e.: {@link Item#fillColor}.
+     * 
+     * To set multiple style properties in one go, you can pass an object to
+     * {@link Item#style}. This is a convenient way to define a style once and
+     * apply it to a series of items:
+     */
+    class Style  {
+        /** 
+         * The view that this style belongs to.
+         */
+        readonly view: View
+
+        /** 
+         * The color of the stroke.
+         */
+        strokeColor: Color
+
+        /** 
+         * The width of the stroke.
+         */
+        strokeWidth: number
+
+        /** 
+         * The shape to be used at the beginning and end of open {@link Path} items,
+         * when they have a stroke.
+         */
+        strokeCap: string
+
+        /** 
+         * The shape to be used at the segments and corners of {@link Path} items
+         * when they have a stroke.
+         */
+        strokeJoin: string
+
+        /** 
+         * Specifies whether the stroke is to be drawn taking the current affine
+         * transformation into account (the default behavior), or whether it should
+         * appear as a non-scaling stroke.
+         */
+        strokeScaling: boolean
+
+        /** 
+         * The dash offset of the stroke.
+         */
+        dashOffset: number
+
+        /** 
+         * Specifies an array containing the dash and gap lengths of the stroke.
+         */
+        dashArray: number[]
+
+        /** 
+         * The miter limit of the stroke. When two line segments meet at a sharp
+         * angle and miter joins have been specified for {@link #strokeJoin}, it is
+         * possible for the miter to extend far beyond the {@link #strokeWidth} of
+         * the path. The miterLimit imposes a limit on the ratio of the miter length
+         * to the {@link #strokeWidth}.
+         */
+        miterLimit: number
+
+        /** 
+         * The fill color.
+         */
+        fillColor: Color
+
+        /** 
+         * The fill-rule with which the shape gets filled. Please note that only
+         * modern browsers support fill-rules other than `'nonzero'`.
+         */
+        fillRule: string
+
+        /** 
+         * The shadow color.
+         */
+        shadowColor: Color
+
+        /** 
+         * The shadow's blur radius.
+         */
+        shadowBlur: number
+
+        /** 
+         * The shadow's offset.
+         */
+        shadowOffset: Point
+
+        /** 
+         * The color the item is highlighted with when selected. If the item does
+         * not specify its own color, the color defined by its layer is used instead.
+         */
+        selectedColor: Color
+
+        /** 
+         * The font-family to be used in text content.
+         */
+        fontFamily: string
+
+        /** 
+         * The font-weight to be used in text content.
+         */
+        fontWeight: string | number
+
+        /** 
+         * The font size of text content, as a number in pixels, or as a string with
+         * optional units `'px'`, `'pt'` and `'em'`.
+         */
+        fontSize: number | string
+
+        /** 
+         * The text leading of text content.
+         */
+        leading: number | string
+
+        /** 
+         * The justification of text paragraphs.
+         */
+        justification: string
+
+
+        /** 
+         * Style objects don't need to be created directly. Just pass an object to
+         * {@link Item#style} or {@link Project#currentStyle}, it will be converted
+         * to a Style object internally.
+         */
+        constructor(style: object)
+
+    }
+
+    /** 
+     * Symbols allow you to place multiple instances of an item in your
+     * project. This can save memory, since all instances of a symbol simply refer
+     * to the original item and it can speed up moving around complex objects, since
+     * internal properties such as segment lists and gradient positions don't need
+     * to be updated with every transformation.
+     */
+    class SymbolDefinition  {
+        /** 
+         * The project that this symbol belongs to.
+         */
+        readonly project: Project
+
+        /** 
+         * The item used as the symbol's definition.
+         */
+        item: Item
+
+
+        /** 
+         * Creates a Symbol definition.
+         * 
+         * @param item - the source item which is removed from the scene graph
+         *     and becomes the symbol's definition.
+         */
+        constructor(item: Item, dontCenter?: boolean)
+
+        /** 
+         * Places in instance of the symbol in the project.
+         * 
+         * @param position - the position of the placed symbol
+         */
+        place(position?: Point): SymbolItem
+
+        /** 
+         * Returns a copy of the symbol.
+         */
+        clone(): SymbolDefinition
+
+        /** 
+         * Checks whether the symbol's definition is equal to the supplied symbol.
+         * 
+         * @return true if they are equal
+         */
+        equals(symbol: SymbolDefinition): boolean
+
+    }
+
+    /** 
+     * A symbol item represents an instance of a symbol which has been
+     * placed in a Paper.js project.
+     */
+    class SymbolItem extends Item {
+        /** 
+         * The symbol definition that the placed symbol refers to.
+         */
+        definition: SymbolDefinition
+
+
+        /** 
+         * Creates a new symbol item.
+         * 
+         * @param definition - the definition to place or an
+         *     item to place as a symbol
+         * @param point - the center point of the placed symbol
+         */
+        constructor(definition: SymbolDefinition | Item, point?: Point)
+
+    }
+
+    /** 
+     * The TextItem type allows you to create typography. Its functionality
+     *     is inherited by different text item types such as {@link PointText}, and
+     *     {@link AreaText} (coming soon). They each add a layer of functionality
+     *     that is unique to their type, but share the underlying properties and
+     *     functions that they inherit from TextItem.
+     */
+    class TextItem extends Item {
+        /** 
+         * The text contents of the text item.
+         */
+        content: string
+
+        /** 
+         * The font-family to be used in text content.
+         */
+        fontFamily: string
+
+        /** 
+         * The font-weight to be used in text content.
+         */
+        fontWeight: string | number
+
+        /** 
+         * The font size of text content, as a number in pixels, or as a string with
+         * optional units `'px'`, `'pt'` and `'em'`.
+         */
+        fontSize: number | string
+
+        /** 
+         * The text leading of text content.
+         */
+        leading: number | string
+
+        /** 
+         * The justification of text paragraphs.
+         */
+        justification: string
+
+
+    }
+
+    /** 
+     * The Tool object refers to a script that the user can interact with by
+     *     using the mouse and keyboard and can be accessed through the global
+     *     `tool` variable. All its properties are also available in the paper
+     *     scope.
+     * 
+     * The global `tool` variable only exists in scripts that contain mouse handler
+     * functions ({@link #onMouseMove}, {@link #onMouseDown}, {@link #onMouseDrag},
+     * {@link #onMouseUp}) or a keyboard handler function ({@link #onKeyDown},
+     * {@link #onKeyUp}).
+     */
+    class Tool  {
+        /** 
+         * The minimum distance the mouse has to drag before firing the onMouseDrag
+         * event, since the last onMouseDrag event.
+         */
+        minDistance: number
+
+        /** 
+         * The maximum distance the mouse has to drag before firing the onMouseDrag
+         * event, since the last onMouseDrag event.
+         */
+        maxDistance: number
+
+        
+        fixedDistance: number
+
+        /** 
+         * The function to be called when the mouse button is pushed down. The
+         * function receives a {@link ToolEvent} object which contains information
+         * about the tool event.
+         */
+        onMouseDown: Function
+
+        /** 
+         * The function to be called when the mouse position changes while the mouse
+         * is being dragged. The function receives a {@link ToolEvent} object which
+         * contains information about the tool event.
+         */
+        onMouseDrag: Function
+
+        /** 
+         * The function to be called the mouse moves within the project view. The
+         * function receives a {@link ToolEvent} object which contains information
+         * about the tool event.
+         */
+        onMouseMove: Function
+
+        /** 
+         * The function to be called when the mouse button is released. The function
+         * receives a {@link ToolEvent} object which contains information about the
+         * tool event.
+         */
+        onMouseUp: Function
+
+        /** 
+         * The function to be called when the user presses a key on the keyboard.
+         * The function receives a {@link KeyEvent} object which contains
+         * information about the keyboard event.
+         * 
+         * If the function returns `false`, the keyboard event will be prevented
+         * from bubbling up. This can be used for example to stop the window from
+         * scrolling, when you need the user to interact with arrow keys.
+         */
+        onKeyDown: Function
+
+        /** 
+         * The function to be called when the user releases a key on the keyboard.
+         * The function receives a {@link KeyEvent} object which contains
+         * information about the keyboard event.
+         * 
+         * If the function returns `false`, the keyboard event will be prevented
+         * from bubbling up. This can be used for example to stop the window from
+         * scrolling, when you need the user to interact with arrow keys.
+         */
+        onKeyUp: Function
+
+
+        /** 
+         * Activates this tool, meaning {@link PaperScope#tool} will
+         * point to it and it will be the one that receives tool events.
+         */
+        activate(): void
+
+        /** 
+         * Removes this tool from the {@link PaperScope#tools} list.
+         */
+        remove(): void
+
+        /** 
+         * Attach an event handler to the tool.
+         * 
+         * @param type - the event type: {@values 'mousedown', 'mouseup',
+         *     'mousedrag', 'mousemove', 'keydown', 'keyup'}
+         * @param function - the function to be called when the event
+         *     occurs, receiving a {@link ToolEvent} object as its sole argument
+         * 
+         * @return this tool itself, so calls can be chained
+         */
+        on(type: string, callback: Function): Tool
+
+        /** 
+         * Attach one or more event handlers to the tool.
+         * 
+         * @param param - an object literal containing one or more of the
+         *     following properties: {@values mousedown, mouseup, mousedrag,
+         *     mousemove, keydown, keyup}
+         * 
+         * @return this tool itself, so calls can be chained
+         */
+        on(param: object): Tool
+
+        /** 
+         * Detach an event handler from the tool.
+         * 
+         * @param type - the event type: {@values 'mousedown', 'mouseup',
+         *     'mousedrag', 'mousemove', 'keydown', 'keyup'}
+         * @param function - the function to be detached
+         * 
+         * @return this tool itself, so calls can be chained
+         */
+        off(type: string, callback: Function): Tool
+
+        /** 
+         * Detach one or more event handlers from the tool.
+         * 
+         * @param param - an object literal containing one or more of the
+         *     following properties: {@values mousedown, mouseup, mousedrag,
+         *     mousemove, keydown, keyup}
+         * 
+         * @return this tool itself, so calls can be chained
+         */
+        off(param: object): Tool
+
+        /** 
+         * Emit an event on the tool.
+         * 
+         * @param type - the event type: {@values 'mousedown', 'mouseup',
+         *     'mousedrag', 'mousemove', 'keydown', 'keyup'}
+         * @param event - an object literal containing properties describing
+         * the event
+         * 
+         * @return true if the event had listeners
+         */
+        emit(type: string, event: object): boolean
+
+        /** 
+         * Check if the tool has one or more event handlers of the specified type.
+         * 
+         * @param type - the event type: {@values 'mousedown', 'mouseup',
+         *     'mousedrag', 'mousemove', 'keydown', 'keyup'}
+         * 
+         * @return true if the tool has one or more event handlers of
+         * the specified type
+         */
+        responds(type: string): boolean
+
+    }
+
+    /** 
+     * ToolEvent The ToolEvent object is received by the {@link Tool}'s mouse
+     * event handlers {@link Tool#onMouseDown}, {@link Tool#onMouseDrag},
+     * {@link Tool#onMouseMove} and {@link Tool#onMouseUp}. The ToolEvent
+     * object is the only parameter passed to these functions and contains
+     * information about the mouse event.
+     */
+    class ToolEvent extends Event {
+        /** 
+         * The type of tool event.
+         */
+        type: string
+
+        /** 
+         * The position of the mouse in project coordinates when the event was
+         * fired.
+         */
+        point: Point
+
+        /** 
+         * The position of the mouse in project coordinates when the previous
+         * event was fired.
+         */
+        lastPoint: Point
+
+        /** 
+         * The position of the mouse in project coordinates when the mouse button
+         * was last clicked.
+         */
+        downPoint: Point
+
+        /** 
+         * The point in the middle between {@link #lastPoint} and
+         * {@link #point}. This is a useful position to use when creating
+         * artwork based on the moving direction of the mouse, as returned by
+         * {@link #delta}.
+         */
+        middlePoint: Point
+
+        /** 
+         * The difference between the current position and the last position of the
+         * mouse when the event was fired. In case of the mouseup event, the
+         * difference to the mousedown position is returned.
+         */
+        delta: Point
+
+        /** 
+         * The number of times the mouse event was fired.
+         */
+        count: number
+
+        /** 
+         * The item at the position of the mouse (if any).
+         * 
+         * If the item is contained within one or more {@link Group} or
+         * {@link CompoundPath} items, the most top level group or compound path
+         * that it is contained within is returned.
+         */
+        item: Item
+
+
+        /** 
+         * @return a string representation of the tool event
+         */
+        toString(): string
+
+    }
+
+    /** 
+     * Allows tweening `Object` properties between two states for a given
+     * duration. To tween properties on Paper.js {@link Item} instances,
+     * {@link Item#tween} can be used, which returns created
+     * tween instance.
+     * 
+     * @see Item#tween(from, to, options)
+     * @see Item#tween(to, options)
+     * @see Item#tween(options)
+     * @see Item#tweenTo(to, options)
+     * @see Item#tweenFrom(from, options)
+     */
+    class Tween  {
+        /** 
+         * The function to be called when the tween is updated. It receives an
+         * object as its sole argument, containing the current progress of the
+         * tweening and the factor calculated by the easing function.
+         */
+        onUpdate: Function
+
+
+        /** 
+         * Creates a new tween.
+         * 
+         * @param object - the object to tween the properties on
+         * @param from - the state at the start of the tweening
+         * @param to - the state at the end of the tweening
+         * @param duration - the duration of the tweening
+         * @param easing - the type of the easing
+         *     function or the easing function
+         * @param start - whether to start tweening automatically
+         */
+        constructor(object: object, from: object, to: object, duration: number, easing?: string | Function, start?: boolean)
+
+        /** 
+         * Set a function that will be executed when the tween completes.
+         * 
+         * @param function - the function to execute when the tween
+         *     completes
+         */
+        then(callback: Function): Tween
+
+        /** 
+         * Start tweening.
+         */
+        start(): Tween
+
+        /** 
+         * Stop tweening.
+         */
+        stop(): Tween
+
+    }
+
+    /** 
+     * The View object wraps an HTML element and handles drawing and user
+     * interaction through mouse and keyboard for it. It offer means to scroll the
+     * view, find the currently visible bounds in project coordinates, or the
+     * center, both useful for constructing artwork that should appear centered on
+     * screen.
+     */
+    class View  {
+        /** 
+         * Controls whether the view is automatically updated in the next animation
+         * frame on changes, or whether you prefer to manually call
+         * {@link #update} or {@link #requestUpdate} after changes.
+         * Note that this is `true` by default, except for Node.js, where manual
+         * updates make more sense.
+         */
+        autoUpdate: boolean
+
+        /** 
+         * The underlying native element.
+         */
+        readonly element: HTMLCanvasElement
+
+        /** 
+         * The ratio between physical pixels and device-independent pixels (DIPs)
+         * of the underlying canvas / device.
+         * It is `1` for normal displays, and `2` or more for
+         * high-resolution displays.
+         */
+        readonly pixelRatio: number
+
+        /** 
+         * The resoltuion of the underlying canvas / device in pixel per inch (DPI).
+         * It is `72` for normal displays, and `144` for high-resolution
+         * displays with a pixel-ratio of `2`.
+         */
+        readonly resolution: number
+
+        /** 
+         * The size of the view. Changing the view's size will resize it's
+         * underlying element.
+         */
+        viewSize: Size
+
+        /** 
+         * The bounds of the currently visible area in project coordinates.
+         */
+        readonly bounds: Rectangle
+
+        /** 
+         * The size of the visible area in project coordinates.
+         */
+        readonly size: Size
+
+        /** 
+         * The center of the visible area in project coordinates.
+         */
+        center: Point
+
+        /** 
+         * The view's zoom factor by which the project coordinates are magnified.
+         * 
+         * @see #scaling
+         */
+        zoom: number
+
+        /** 
+         * The current rotation angle of the view, as described by its
+         * {@link #matrix}.
+         */
+        rotation: number
+
+        /** 
+         * The current scale factor of the view, as described by its
+         * {@link #matrix}.
+         * 
+         * @see #zoom
+         */
+        scaling: Point
+
+        /** 
+         * The view's transformation matrix, defining the view onto the project's
+         * contents (position, zoom level, rotation, etc).
+         */
+        matrix: Matrix
+
+        /** 
+         * Handler function to be called on each frame of an animation.
+         * The function receives an event object which contains information about
+         * the frame event:
+         * 
+         * @see Item#onFrame
+         * 
+         * @option event.count {Number} the number of times the frame event was
+         * fired
+         * @option event.time {Number} the total amount of time passed since the
+         * first frame event in seconds
+         * @option event.delta {Number} the time passed in seconds since the last
+         * frame event
+         */
+        onFrame: Function
+
+        /** 
+         * Handler function that is called whenever a view is resized.
+         */
+        onResize: Function
+
+        /** 
+         * The function to be called when the mouse button is pushed down on the
+         * view. The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onMouseDown
+         */
+        onMouseDown: Function
+
+        /** 
+         * The function to be called when the mouse position changes while the mouse
+         * is being dragged over the view. The function receives a {@link
+         * MouseEvent} object which contains information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onMouseDrag
+         */
+        onMouseDrag: Function
+
+        /** 
+         * The function to be called when the mouse button is released over the item.
+         * The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * 
+         * @see Item#onMouseUp
+         */
+        onMouseUp: Function
+
+        /** 
+         * The function to be called when the mouse clicks on the view. The function
+         * receives a {@link MouseEvent} object which contains information about the
+         * mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onClick
+         */
+        onClick: Function
+
+        /** 
+         * The function to be called when the mouse double clicks on the view. The
+         * function receives a {@link MouseEvent} object which contains information
+         * about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onDoubleClick
+         */
+        onDoubleClick: Function
+
+        /** 
+         * The function to be called repeatedly while the mouse moves over the
+         * view. The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onMouseMove
+         */
+        onMouseMove: Function
+
+        /** 
+         * The function to be called when the mouse moves over the view. This
+         * function will only be called again, once the mouse moved outside of the
+         * view first. The function receives a {@link MouseEvent} object which
+         * contains information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see Item#onMouseEnter
+         */
+        onMouseEnter: Function
+
+        /** 
+         * The function to be called when the mouse moves out of the view.
+         * The function receives a {@link MouseEvent} object which contains
+         * information about the mouse event.
+         * Note that such mouse events bubble up the scene graph hierarchy, reaching
+         * the view at the end, unless they are stopped before with {@link
+         * Event#stopPropagation()} or by returning `false` from a handler.
+         * 
+         * @see View#onMouseLeave
+         */
+        onMouseLeave: Function
+
+
+        /** 
+         * Shears the view by the given values from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(hor, ver[, center])
+         * 
+         * @param hor - the horizontal shear factor
+         * @param ver - the vertical shear factor
+         */
+        shear(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Removes this view from the project and frees the associated element.
+         */
+        remove(): void
+
+        /** 
+         * Requests an update of the view if there are changes through the browser's
+         * requestAnimationFrame() mechanism for smooth animation. Note that when
+         * using built-in event handlers for interaction, animation and load events,
+         * updates are automatically invoked for you automatically at the end.
+         */
+        requestUpdate(): void
+
+        /** 
+         * Makes all animation play by adding the view to the request animation
+         * loop.
+         */
+        play(): void
+
+        /** 
+         * Makes all animation pause by removing the view from the request animation
+         * loop.
+         */
+        pause(): void
+
+        /** 
+         * Checks whether the view is currently visible within the current browser
+         * viewport.
+         * 
+         * @return true if the view is visible
+         */
+        isVisible(): boolean
+
+        /** 
+         * Checks whether the view is inserted into the browser DOM.
+         * 
+         * @return true if the view is inserted
+         */
+        isInserted(): boolean
+
+        /** 
+         * Translates (scrolls) the view by the given offset vector.
+         * 
+         * @param delta - the offset to translate the view by
+         */
+        translate(delta: Point): void
+
+        /** 
+         * Rotates the view by a given angle around the given center point.
+         * 
+         * Angles are oriented clockwise and measured in degrees.
+         * 
+         * @see Matrix#rotate(angle[, center])
+         * 
+         * @param angle - the rotation angle
+         */
+        rotate(angle: number, center?: Point): void
+
+        /** 
+         * Scales the view by the given value from its center point, or optionally
+         * from a supplied point.
+         * 
+         * @param scale - the scale factor
+         */
+        scale(scale: number, center?: Point): void
+
+        /** 
+         * Scales the view by the given values from its center point, or optionally
+         * from a supplied point.
+         * 
+         * @param hor - the horizontal scale factor
+         * @param ver - the vertical scale factor
+         */
+        scale(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Shears the view by the given value from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(shear[, center])
+         * 
+         * @param shear - the horziontal and vertical shear factors as a point
+         */
+        shear(shear: Point, center?: Point): void
+
+        /** 
+         * Updates the view if there are changes. Note that when using built-in
+         * event hanlders for interaction, animation and load events, this method is
+         * invoked for you automatically at the end.
+         * 
+         * @return true if the view was updated
+         */
+        update(): boolean
+
+        /** 
+         * Skews the view by the given angles from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(skew[, center])
+         * 
+         * @param skew - the horziontal and vertical skew angles in degrees
+         */
+        skew(skew: Point, center?: Point): void
+
+        /** 
+         * Skews the view by the given angles from its center point, or optionally
+         * by a supplied point.
+         * 
+         * @see Matrix#shear(hor, ver[, center])
+         * 
+         * @param hor - the horizontal skew angle in degrees
+         * @param ver - the vertical sskew angle in degrees
+         */
+        skew(hor: number, ver: number, center?: Point): void
+
+        /** 
+         * Transform the view.
+         * 
+         * @param matrix - the matrix by which the view shall be transformed
+         */
+        transform(matrix: Matrix): void
+
+        /** 
+         * Converts the passed point from project coordinate space to view
+         * coordinate space, which is measured in browser pixels in relation to the
+         * position of the view element.
+         * 
+         * @param point - the point in project coordinates to be converted
+         * 
+         * @return the point converted into view coordinates
+         */
+        projectToView(point: Point): Point
+
+        /** 
+         * Converts the passed point from view coordinate space to project
+         * coordinate space.
+         * 
+         * @param point - the point in view coordinates to be converted
+         * 
+         * @return the point converted into project coordinates
+         */
+        viewToProject(point: Point): Point
+
+        /** 
+         * Determines and returns the event location in project coordinate space.
+         * 
+         * @param event - the native event object for which to determine the
+         *     location.
+         * 
+         * @return the event point in project coordinates.
+         */
+        getEventPoint(event: Event): Point
+
+        /** 
+         * Attach an event handler to the view.
+         * 
+         * @param type - the type of event: {@values 'frame', 'resize',
+         *     'mousedown', 'mouseup', 'mousedrag', 'click', 'doubleclick',
+         *     'mousemove', 'mouseenter', 'mouseleave'}
+         * @param function - the function to be called when the event
+         *     occurs, receiving a {@link MouseEvent} or {@link Event} object as its
+         *     sole argument
+         * 
+         * @return this view itself, so calls can be chained
+         */
+        on(type: string, callback: Function): View
+
+        /** 
+         * Attach one or more event handlers to the view.
+         * 
+         * @param param - an object literal containing one or more of the
+         *     following properties: {@values frame, resize}
+         * 
+         * @return this view itself, so calls can be chained
+         */
+        on(param: object): View
+
+        /** 
+         * Detach an event handler from the view.
+         * 
+         * @param type - the event type: {@values 'frame', 'resize',
+         *     'mousedown', 'mouseup', 'mousedrag', 'click', 'doubleclick',
+         *     'mousemove', 'mouseenter', 'mouseleave'}
+         * @param function - the function to be detached
+         * 
+         * @return this view itself, so calls can be chained
+         */
+        off(type: string, callback: Function): View
+
+        /** 
+         * Detach one or more event handlers from the view.
+         * 
+         * @param param - an object literal containing one or more of the
+         *     following properties: {@values frame, resize}
+         * 
+         * @return this view itself, so calls can be chained
+         */
+        off(param: object): View
+
+        /** 
+         * Emit an event on the view.
+         * 
+         * @param type - the event type: {@values 'frame', 'resize',
+         *     'mousedown', 'mouseup', 'mousedrag', 'click', 'doubleclick',
+         *     'mousemove', 'mouseenter', 'mouseleave'}
+         * @param event - an object literal containing properties describing
+         * the event
+         * 
+         * @return true if the event had listeners
+         */
+        emit(type: string, event: object): boolean
+
+        /** 
+         * Check if the view has one or more event handlers of the specified type.
+         * 
+         * @param type - the event type: {@values 'frame', 'resize',
+         *     'mousedown', 'mouseup', 'mousedrag', 'click', 'doubleclick',
+         *     'mousemove', 'mouseenter', 'mouseleave'}
+         * 
+         * @return true if the view has one or more event handlers of
+         * the specified type
+         */
+        responds(type: string): boolean
+
+    }
+}
+
+declare module 'paper' {
+    export = paper
+}
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 73d36d78..60ae771f 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -41,7 +41,7 @@ gulp.task('publish', function() {
     return run(
         'publish:json',
         'publish:dist',
-        'publish:packages',
+        // 'publish:packages',
         'publish:commit',
         'publish:website',
         'publish:release',
diff --git a/package.json b/package.json
index 62191a19..1f03ac04 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
@@ -9,10 +9,7 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": [
-    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
-    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
-  ],
+  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
   "scripts": {
@@ -24,14 +21,7 @@
     "jshint": "gulp jshint",
     "test": "gulp test"
   },
-  "files": [
-    "AUTHORS.md",
-    "CHANGELOG.md",
-    "dist/",
-    "examples/",
-    "LICENSE.txt",
-    "README.md"
-  ],
+  "files": ["AUTHORS.md", "CHANGELOG.md", "dist/", "examples/", "LICENSE.txt", "README.md"],
   "engines": {
     "node": ">=8.0.0"
   },
@@ -86,21 +76,5 @@
     "straps": "^3.0.1",
     "typescript": "^3.1.6"
   },
-  "keywords": [
-    "vector",
-    "graphic",
-    "graphics",
-    "2d",
-    "geometry",
-    "bezier",
-    "curve",
-    "curves",
-    "path",
-    "paths",
-    "canvas",
-    "svg",
-    "paper",
-    "paper.js",
-    "paperjs"
-  ]
+  "keywords": ["vector", "graphic", "graphics", "2d", "geometry", "bezier", "curve", "curves", "path", "paths", "canvas", "svg", "paper", "paper.js", "paperjs"]
 }
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index c3f05571..8d047809 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit c3f055710eb887af55ea7039fbba50c9592fa4c4
+Subproject commit 8d04780979504ff54994e0af2726542c3be3bced
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index c4b63823..1c9a5935 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit c4b6382389f13c065c4dc9be430b3bec2326dc23
+Subproject commit 1c9a593502d101d9802668c64163c33bdadbc229
diff --git a/src/options.js b/src/options.js
index 5d7dc14d..e92de00f 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.0';
+var version = '0.12.1';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From c9ee21ee378e47f9c0044b8cb63294812ecff41b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 6 Jun 2019 00:13:21 +0200
Subject: [PATCH 065/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15281 +-------------------------------------
 dist/paper-full.js | 17025 +------------------------------------------
 2 files changed, 2 insertions(+), 32304 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 4ea56b36..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15280 +0,0 @@
-/*!
- * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Thu Jun 6 00:04:28 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg))
-							arg.insert = false;
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = n === 'trident' ? 'msie' : n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-			agent.node = agent.jsdom;
-		}
-	},
-
-	version: "0.12.1",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty()) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function() {
-		var children = this._children;
-		return !children || !children.length;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish)
-			ctx.clip();
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(
-				matrix && matrix.appended(clipItem._matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-
-		var image,
-			type = typeof source,
-			object = type === 'string'
-				? document.getElementById(source)
-				: type  === 'object'
-					? source
-					: null;
-		if (object && object !== Item.NO_INSERT) {
-			if (object.getContent || object.naturalHeight != null) {
-				image = object;
-			} else if (object) {
-				var size = Size.read(arguments);
-				if (!size.isZero()) {
-					image = CanvasProvider.getCanvas(size);
-				}
-			}
-		}
-
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		var half = size / 2,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (!(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			var epsilon = 1e-7,
-				ext = abs(extent),
-				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-				inc = extent / count,
-				half = inc * Math.PI / 360,
-				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-				segments = [];
-			for (var i = 0; i <= count; i++) {
-				var pt = to,
-					out = null;
-				if (i < count) {
-					out = vector.rotate(90).multiply(z);
-					if (matrix) {
-						pt = matrix._transformPoint(vector);
-						out = matrix._transformPoint(vector.add(out))
-								.subtract(pt);
-					} else {
-						pt = center.add(vector);
-					}
-				}
-				if (!i) {
-					current.setHandleOut(out);
-				} else {
-					var _in = vector.rotate(-90).multiply(z);
-					if (matrix) {
-						_in = matrix._transformPoint(vector.add(_in))
-								.subtract(pt);
-					}
-					segments.push(new Segment(pt, _in, out));
-				}
-				vector = vector.rotate(inc);
-			}
-			this._add(segments);
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix);
-		if (normal1.getDirectedAngle(normal2) < 0) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner)
-				this._owner._changed(129);
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		var color = Color.read(arguments, 0, { clone: true });
-		if (color)
-			color._owner = this;
-		this._color = color;
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old && old._owner !== undefined) {
-							old._owner = undefined;
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							if (value._owner)
-								value = value.clone();
-							value._owner = owner;
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone)
-						value = value.clone();
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-						if (value && isColor)
-							value._owner = owner;
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			matrix = matrix._shiftless();
-			var point = matrix._inverseTransform(trans);
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-			trans = null;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.y)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent) {
-		var value = SvgElement.get(node, name),
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
-			destination = origin.add(
-					getValue(node, 'r', false, false, scaleToBounds), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		}
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index 83489cfe..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17024 +0,0 @@
-/*!
- * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Thu Jun 6 00:04:28 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg))
-							arg.insert = false;
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = n === 'trident' ? 'msie' : n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-			agent.node = agent.jsdom;
-		}
-	},
-
-	version: "0.12.1",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty()) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function() {
-		var children = this._children;
-		return !children || !children.length;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish)
-			ctx.clip();
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(
-				matrix && matrix.appended(clipItem._matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-
-		var image,
-			type = typeof source,
-			object = type === 'string'
-				? document.getElementById(source)
-				: type  === 'object'
-					? source
-					: null;
-		if (object && object !== Item.NO_INSERT) {
-			if (object.getContent || object.naturalHeight != null) {
-				image = object;
-			} else if (object) {
-				var size = Size.read(arguments);
-				if (!size.isZero()) {
-					image = CanvasProvider.getCanvas(size);
-				}
-			}
-		}
-
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		var half = size / 2,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (!(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			var epsilon = 1e-7,
-				ext = abs(extent),
-				count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-				inc = extent / count,
-				half = inc * Math.PI / 360,
-				z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-				segments = [];
-			for (var i = 0; i <= count; i++) {
-				var pt = to,
-					out = null;
-				if (i < count) {
-					out = vector.rotate(90).multiply(z);
-					if (matrix) {
-						pt = matrix._transformPoint(vector);
-						out = matrix._transformPoint(vector.add(out))
-								.subtract(pt);
-					} else {
-						pt = center.add(vector);
-					}
-				}
-				if (!i) {
-					current.setHandleOut(out);
-				} else {
-					var _in = vector.rotate(-90).multiply(z);
-					if (matrix) {
-						_in = matrix._transformPoint(vector.add(_in))
-								.subtract(pt);
-					}
-					segments.push(new Segment(pt, _in, out));
-				}
-				vector = vector.rotate(inc);
-			}
-			this._add(segments);
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix);
-		if (normal1.getDirectedAngle(normal2) < 0) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner)
-				this._owner._changed(129);
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		var color = Color.read(arguments, 0, { clone: true });
-		if (color)
-			color._owner = this;
-		this._color = color;
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old && old._owner !== undefined) {
-							old._owner = undefined;
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							if (value._owner)
-								value = value.clone();
-							value._owner = owner;
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone)
-						value = value.clone();
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-						if (value && isColor)
-							value._owner = owner;
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			matrix = matrix._shiftless();
-			var point = matrix._inverseTransform(trans);
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-			trans = null;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.y)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent) {
-		var value = SvgElement.get(node, name),
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
-			destination = origin.add(
-					getValue(node, 'r', false, false, scaleToBounds), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		}
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (!node.prefix
-								&& (parentType === 'AssignmentExpression'
-									|| parentType === 'VariableDeclarator')) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, view: view, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From 33a562593675dd9fc3d6f8e3f7c88079d2f1a102 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 6 Jun 2019 00:15:23 +0200
Subject: [PATCH 066/181] =?UTF-8?q?Reactivate=20=E2=80=98publish:packages?=
 =?UTF-8?q?=E2=80=99=20script?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 gulp/tasks/publish.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 60ae771f..73d36d78 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -41,7 +41,7 @@ gulp.task('publish', function() {
     return run(
         'publish:json',
         'publish:dist',
-        // 'publish:packages',
+        'publish:packages',
         'publish:commit',
         'publish:website',
         'publish:release',

From 598d9a3356ca4be1a62fbd880940f644ad5939de Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Fri, 7 Jun 2019 15:06:46 +0200
Subject: [PATCH 067/181] Add SVG switch support (#1597)

SVG <switch> is simply parsed as a group because conditional attributes
cannot be evaluated in paper.js context.
Relates to #1389
---
 src/svg/SvgImport.js    |  6 +++++-
 test/tests/SvgImport.js | 15 +++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 829d7b19..2deb2b8c 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -303,7 +303,11 @@ new function() {
                     getPoint(node, 'dx', 'dy')));
             text.setContent(node.textContent.trim() || '');
             return text;
-        }
+        },
+
+        // https://www.w3.org/TR/SVG/struct.html#SwitchElement
+        // Conditional attributes are ignored and all children are rendered.
+        switch: importGroup
     };
 
     // Attributes and Styles
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index a0c3e261..fbd13ff2 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -143,6 +143,21 @@ test('Import SVG without insertion', function() {
     }, true);
 });
 
+test('Import SVG switch', function(assert) {
+    var done = assert.async();
+    var svg = '<svg xmlns="http://www.w3.org/2000/svg"><switch><line x1="0" x2="10" y1="0" y2="10" fill="none"></line></switch></svg>';
+    paper.project.importSVG(svg, {
+        onLoad: function(item) {
+            equals(item.className, 'Group');
+            equals(item.children.length, 1);
+            equals(item.firstChild.className, 'Group');
+            equals(item.firstChild.children.length, 1);
+            equals(item.firstChild.firstChild, new Path([new Point(0, 0), new Point(10, 10)]));
+            done();
+        }
+    });
+});
+
 function importSVG(assert, url, message, options) {
     var done = assert.async();
     project.importSVG(url, {

From 43ec69906342ffe58dbaa69ec6836ce16efb1c0f Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Fri, 7 Jun 2019 17:19:59 +0200
Subject: [PATCH 068/181] Fix path selection drawing with low handle size
 (#1600)

Closes #1327
---
 src/path/Path.js | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/path/Path.js b/src/path/Path.js
index d9e631f7..353a7c14 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2173,6 +2173,11 @@ new function() { // Scope for drawing
     // performance.
 
     function drawHandles(ctx, segments, matrix, size) {
+        // Only draw if size is not null or negative.
+        if (size <= 0) {
+            return;
+        }
+
         var half = size / 2,
             coords = new Array(6),
             pX, pY;
@@ -2204,8 +2209,8 @@ new function() { // Scope for drawing
             // Draw a rectangle at segment.point:
             ctx.fillRect(pX - half, pY - half, size, size);
             // If the point is not selected, draw a white square that is 1 px
-            // smaller on all sides:
-            if (!(selection & /*#=*/SegmentSelection.POINT)) {
+            // smaller on all sides. Only draw it if size is big enough (#1327).
+            if (!(selection & /*#=*/SegmentSelection.POINT) && size > 2) {
                 var fillStyle = ctx.fillStyle;
                 ctx.fillStyle = '#ffffff';
                 ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);

From 314390d78911580a0bb43463598c9bbb881b4a9e Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 5 Dec 2018 10:25:56 +0100
Subject: [PATCH 069/181] Improve `new Raster(size[, position])` constructor

Closes #1621
---
 CHANGELOG.md         | 10 ++++--
 src/item/Raster.js   | 85 +++++++++++++++++++++++++++++---------------
 test/tests/Raster.js | 28 +++++++++++++++
 3 files changed, 92 insertions(+), 31 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b4d47d00..56819915 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,18 @@
 # Change Log
 
-## 0.12.1
+# `prebuilt`
+
+### Added
+
+- Improve `new Raster(size[, position])` constructor (#1621).
+
+# `0.12.1`
 
 ### Added
 
 - Add TypesScript definition, automatically generated from JSDoc comments
   (#1612).
-- Support `new Raster(size)` constructor.
+- Support `new Raster(size[, position])` constructor.
 - Expose `Raster#context` accessor.
 - Implement `Raster#clear()` method to clear associated canvas context.
 - Node.js: Add support for Node.js v11 and v12.
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 6d784a58..ee279d96 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -40,10 +40,11 @@ var Raster = Item.extend(/** @lends Raster# */{
     // TODO: Have SymbolItem & Raster inherit from a shared class?
     /**
      * Creates a new raster item from the passed argument, and places it in the
-     * active layer. `object` can either be a DOM Image, a Canvas, or a string
+     * active layer. `source` can either be a DOM Image, a Canvas, or a string
      * describing the URL to load the image from, or the ID of a DOM element to
      * get the image from (either a DOM Image or a Canvas).
      *
+     * @name Raster#initialize
      * @param {HTMLImageElement|HTMLCanvasElement|String} [source] the source of
      *     the raster
      * @param {Point} [position] the center position at which the raster item is
@@ -81,37 +82,61 @@ var Raster = Item.extend(/** @lends Raster# */{
      * raster.scale(0.5);
      * raster.rotate(10);
      */
+    /**
+     * Creates a new empty raster of the given size, and places it in the
+     * active layer.
+     *
+     * @name Raster#initialize
+     * @param {Size} size the size of the raster
+     * @param {Point} [position] the center position at which the raster item is
+     *     placed
+     *
+     * @example {@paperscript height=150}
+     * // Creating an empty raster and fill it with random pixels:
+     * var width = 100;
+     * var height = 100;
+     *
+     * // Create an empty raster placed at view center.
+     * var raster = new Raster(new Size(width, height), view.center);
+     *
+     * // For all of its pixels...
+     * for (var i = 0; i < width; i++) {
+     *     for (var j = 0; j < height; j++) {
+     *         // ...set a random color.
+     *         raster.setPixel(i, j, Color.random());
+     *     }
+     * }
+     */
     initialize: function Raster(source, position) {
-        // Support two forms of item initialization: Passing one object literal
-        // describing all the different properties to be set, or an image
-        // (object) and a point where it should be placed (point).
+        // Support three forms of item initialization:
+        // - One object literal describing all the different properties.
+        // - An image (Image|Canvas|String) and an optional position (Point).
+        // - A size (Size) describing the canvas that will be  created and an
+        //   optional position (Point).
         // If _initialize can set properties through object literal, we're done.
-        // Otherwise we need to check the type of object:
-
-        // source can be an image, canvas, source URL or DOM-ID:
-        var image,
-            type = typeof source,
-            object = type === 'string'
-                ? document.getElementById(source)
-                : type  === 'object'
-                    ? source
-                    : null;
-        if (object && object !== Item.NO_INSERT) {
-            // #setImage() handles both canvas and image types.
-            if (object.getContent || object.naturalHeight != null) {
-                image = object;
-            } else if (object) {
-                // See if the arguments describe the raster size:
-                var size = Size.read(arguments);
-                if (!size.isZero()) {
-                    image = CanvasProvider.getCanvas(size);
-                }
-            }
-        }
-
+        // Otherwise we need to check the type of object:       var image,
         if (!this._initialize(source,
                 position !== undefined && Point.read(arguments))) {
+            var image,
+                type = typeof source,
+                object = type === 'string'
+                    ? document.getElementById(source)
+                    : type  === 'object'
+                        ? source
+                        : null;
+            if (object && object !== Item.NO_INSERT) {
+                if (object.getContent || object.naturalHeight != null) {
+                    image = object;
+                } else if (object) {
+                    // See if the arguments describe the raster size:
+                    var size = Size.read(arguments);
+                    if (!size.isZero()) {
+                        image = CanvasProvider.getCanvas(size);
+                    }
+                }
+            }
             if (image) {
+                // #setImage() handles both canvas and image types.
                 this.setImage(image);
             } else {
                 this.setSource(source);
@@ -641,7 +666,8 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#getPixel
      * @function
-     * @param {Point} point the offset of the pixel as a point in pixel coordinates
+     * @param {Point} point the offset of the pixel as a point in pixel
+     *     coordinates
      * @return {Color} the color of the pixel
      */
     getPixel: function(/* point */) {
@@ -666,7 +692,8 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#setPixel
      * @function
-     * @param {Point} point the offset of the pixel as a point in pixel coordinates
+     * @param {Point} point the offset of the pixel as a point in pixel
+     *     coordinates
      * @param {Color} color the color that the pixel will be set to
      */
     setPixel: function(/* point, color */) {
diff --git a/test/tests/Raster.js b/test/tests/Raster.js
index eb13e11a..32f56fbf 100644
--- a/test/tests/Raster.js
+++ b/test/tests/Raster.js
@@ -206,3 +206,31 @@ test('Raster#setSmoothing setting does not impact canvas context', function(asse
         done();
     };
 });
+
+test('new Raster(size[, position])', function() {
+    // Size only.
+    var raster = new Raster(new Size(100, 100));
+    equals(raster.position, new Point(0, 0));
+    equals(raster.bounds, new Rectangle(-50, -50, 100, 100));
+
+    var raster = new Raster({size:new Size(100, 100)});
+    equals(raster.position, new Point(0, 0));
+    equals(raster.bounds, new Rectangle(-50, -50, 100, 100));
+
+    var raster = new Raster({width:100, height:100});
+    equals(raster.position, new Point(0, 0));
+    equals(raster.bounds, new Rectangle(-50, -50, 100, 100));
+
+    // Size and position.
+    var raster = new Raster(new Size(100, 100), new Point(100, 100));
+    equals(raster.position, new Point(100, 100));
+    equals(raster.bounds, new Rectangle(50, 50, 100, 100));
+
+    var raster = new Raster({size:new Size(100, 100), position:new Point(100, 100)});
+    equals(raster.position, new Point(100, 100));
+    equals(raster.bounds, new Rectangle(50, 50, 100, 100));
+
+    var raster = new Raster({width:100, height:100, position:new Point(100, 100)});
+    equals(raster.position, new Point(100, 100));
+    equals(raster.bounds, new Rectangle(50, 50, 100, 100));
+});

From de824e184617f3d8454482eb1825dc13b6ed554e Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Fri, 7 Jun 2019 22:30:01 +0200
Subject: [PATCH 070/181] Fix exported SVG missing viewBox attribute (#1576)

SVG viewBox attribute was not added when bounds rectangle point was 0,0.
---
 src/svg/SvgExport.js    | 2 +-
 test/tests/SvgExport.js | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index 5048bc2c..9dc464a3 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -427,7 +427,7 @@ new function() {
             if (rect) {
                 attrs.width = rect.width;
                 attrs.height = rect.height;
-                if (rect.x || rect.y)
+                if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
                     attrs.viewBox = formatter.rectangle(rect);
             }
             var node = SvgElement.create('svg', attrs, formatter),
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index e50225c2..004a3f27 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -113,6 +113,12 @@ test('Export SVG path at precision 0', function() {
     equals(path.exportSVG({ precision: 0 }).getAttribute('d'), 'M0,2l1,1');
 });
 
+test('Export SVG viewbox attribute with top left at origin', function() {
+    var path = new Path.Rectangle(new Point(10, 10), new Size(80));
+    var rectangle = new Rectangle(new Point(0, 0), new Size(100));
+    equals(project.exportSVG({ bounds: rectangle }).getAttribute('viewBox'), '0,0,100,100');
+});
+
 if (!isNode) {
     // JSDom does not have SVG rendering, so we can't test there.
     test('Export transformed shapes', function(assert) {

From c30767ed2e2637c3954e046043c710d12e2417ca Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Wed, 24 Oct 2018 19:05:32 +0900
Subject: [PATCH 071/181] Fix SvgExport when item.matrix is not invertible

---
 CHANGELOG.md            |  4 ++++
 src/svg/SvgExport.js    | 11 ++++++++---
 test/tests/SvgExport.js | 11 +++++++++++
 3 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56819915..caec7c8f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@
 
 - Improve `new Raster(size[, position])` constructor (#1621).
 
+### Fixed
+
+- Fix error in `Item#exportSVG()` when `Item#matrix` is not invertible (#1580).
+
 # `0.12.1`
 
 ### Added
diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index 9dc464a3..fcd982a5 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -29,11 +29,16 @@ new function() {
             // in rotate(). To do so, SVG requries us to inverse transform the
             // translation point by the matrix itself, since they are provided
             // in local coordinates.
-            matrix = matrix._shiftless();
-            var point = matrix._inverseTransform(trans);
+            var point;
+            if (matrix.isInvertible()) {
+                matrix = matrix._shiftless();
+                point = matrix._inverseTransform(trans);
+                trans = null;
+            } else {
+                point = new Point();
+            }
             attrs[center ? 'cx' : 'x'] = point.x;
             attrs[center ? 'cy' : 'y'] = point.y;
-            trans = null;
         }
         if (!matrix.isIdentity()) {
             // See if we can decompose the matrix and can formulate it as a
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index 004a3f27..edcdd733 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -155,6 +155,17 @@ if (!isNode) {
         compareSVG(assert.async(), svg, project.activeLayer);
     });
 
+    test('Export not invertible item.matrix', function(assert) {
+        var rect = new Shape.Rectangle({
+            point: [100, 100],
+            size: [100, 100],
+            fillColor: 'red',
+            matrix: [1, 1, 1, 1, 1, 1]
+        });
+        var svg = project.exportSVG({ bounds: 'content', asString: true });
+        compareSVG(assert.async(), svg, project.activeLayer);
+    });
+
     test('Export gradients', function(assert) {
         var bounds = new Rectangle(new Size(300, 600));
         var stops = [new Color(1, 1, 0, 0), 'red', 'black'];

From 10bdafa82685b011a571c0e75a9d763af9cde675 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 13:42:20 +0200
Subject: [PATCH 072/181] Simplify preserving of native classes in tests

---
 src/load.js     |  7 -------
 test/helpers.js | 24 ++++++++----------------
 2 files changed, 8 insertions(+), 23 deletions(-)

diff --git a/src/load.js b/src/load.js
index 061ac532..2da037a9 100644
--- a/src/load.js
+++ b/src/load.js
@@ -36,13 +36,6 @@ if (typeof window === 'object') {
         // the code the 2nd time around.
         load(root + 'src/load.js');
     } else {
-        // Some native javascript classes have name collisions with Paper.js
-        // classes. Store them to be able to use them later in tests.
-        NativeClasses = {
-            Event: Event,
-            MouseEvent: MouseEvent
-        };
-
         include('options.js');
         // Load constants.js, required by the on-the-fly preprocessing:
         include('constants.js');
diff --git a/test/helpers.js b/test/helpers.js
index b6b17392..6b98f55e 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -35,14 +35,11 @@ if (isNode) {
 }
 
 // Some native javascript classes have name collisions with Paper.js classes.
-// If they have not already been stored in src/load.js, we dot it now.
-if (!isNode && typeof NativeClasses === 'undefined')
-{
-    NativeClasses = {
-        Event: Event,
-        MouseEvent: MouseEvent
-    };
-}
+// Store them before `paper.install()` to be able to use them later in tests.
+var nativeClasses = {
+    Event: Event,
+    MouseEvent: MouseEvent
+};
 
 // The unit-tests expect the paper classes to be global.
 paper.install(scope);
@@ -662,8 +659,8 @@ var MouseEventPolyfill = function(type, params) {
     );
     return mouseEvent;
 };
-MouseEventPolyfill.prototype = typeof NativeClasses !== 'undefined'
-    && NativeClasses.Event.prototype || Event.prototype;
+
+MouseEventPolyfill.prototype = nativeClasses.Event.prototype;
 
 var triggerMouseEvent = function(type, point, target) {
     // Depending on event type, events have to be triggered on different
@@ -676,14 +673,9 @@ var triggerMouseEvent = function(type, point, target) {
     // If `gulp load` was run, there is a name collision between paper Event /
     // MouseEvent and native javascript classes. In this case, we need to use
     // native classes stored in global NativeClasses object instead.
-    var constructor = typeof NativeClasses !== 'undefined'
-        && NativeClasses.MouseEvent || MouseEvent;
-
     // MouseEvent class does not exist in PhantomJS, so in that case, we need to
     // use a polyfill method.
-    if (typeof constructor !== 'function') {
-        constructor = MouseEventPolyfill;
-    }
+    var constructor = nativeClasses.MouseEvent || MouseEventPolyfill;
 
     var event = new constructor(type, {
         bubbles: true,

From 7e850d0e55d7b348244b9f3cf10f42e930a472c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 13:55:41 +0200
Subject: [PATCH 073/181] Fix resemble.js warnings during tests

---
 test/helpers.js | 41 +++++++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/test/helpers.js b/test/helpers.js
index 6b98f55e..8e8fba2d 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -185,23 +185,30 @@ var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
 
     tolerance = (tolerance || 1e-4) * 100;
 
-    // Use resemble.js to compare image datas.
     var id = QUnit.config.current.testId,
         index = QUnit.config.current.assertions.length + 1,
         result;
-    if (!resemble._setup) {
-        resemble._setup = true;
-        resemble.outputSettings({
-            errorColor: { red: 255, green: 51, blue: 0 },
-            errorType: 'flat',
-            transparency: 1
-        });
-    }
-    resemble(imageData1)
-        .compareTo(imageData2)
-        .ignoreAntialiasing()
+    // Compare image-data using resemble.js:
+    resemble.compare(
+        imageData1,
+        imageData2,
+        {
+            output: {
+                errorColor: { red: 255, green: 51, blue: 0 },
+                errorType: 'flat',
+                transparency: 1
+            },
+            ignore: ['antialiasing']
+        },
         // When working with imageData, this call is synchronous:
-        .onComplete(function(data) { result = data; });
+        function (error, data) {
+            if (error) {
+                console.error(error);
+            } else {
+                result = data;
+            }
+        }
+    )
     // Compare with tolerance in percentage...
     var fixed = tolerance < 1 ? ((1 / tolerance) + '').length - 1 : 0,
         identical = result ? 100 - result.misMatchPercentage : 0,
@@ -668,16 +675,14 @@ var triggerMouseEvent = function(type, point, target) {
     // and `docEvents` in View.js). And we cannot rely on the fact that event
     // will bubble from canvas to document, since the canvas used in tests is
     // not inserted in DOM.
-    target = target || (type === 'mousedown' ? view._element : document);
-
+    target = target || (type === 'mousedown' ? view.element : document);
     // If `gulp load` was run, there is a name collision between paper Event /
     // MouseEvent and native javascript classes. In this case, we need to use
     // native classes stored in global NativeClasses object instead.
     // MouseEvent class does not exist in PhantomJS, so in that case, we need to
     // use a polyfill method.
-    var constructor = nativeClasses.MouseEvent || MouseEventPolyfill;
-
-    var event = new constructor(type, {
+    var MouseEvent = nativeClasses.MouseEvent || MouseEventPolyfill;
+    var event = new MouseEvent(type, {
         bubbles: true,
         cancelable: true,
         composed: true,

From 4f282cec4b6ab9bb678837159f4218a2c5bdda8b Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Tue, 8 Jan 2019 12:32:21 +0100
Subject: [PATCH 074/181] Fix SVG imported gradients default values

Add default values based on SVG specification document.
Closes #1632
---
 CHANGELOG.md                |  3 ++-
 src/svg/SvgImport.js        | 22 +++++++++++++---------
 test/assets/gradients-3.svg | 17 +++++++++++++++++
 test/tests/SvgImport.js     |  3 ++-
 4 files changed, 34 insertions(+), 11 deletions(-)
 create mode 100644 test/assets/gradients-3.svg

diff --git a/CHANGELOG.md b/CHANGELOG.md
index caec7c8f..793e6bc6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,8 @@
 
 ### Fixed
 
-- Fix error in `Item#exportSVG()` when `Item#matrix` is not invertible (#1580).
+- SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
+- SVG Import: Fix gradient default values (#1632).
 
 # `0.12.1`
 
diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 2deb2b8c..1ad28fb4 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -22,11 +22,12 @@ new function() {
     var definitions = {},
         rootSize;
 
-    function getValue(node, name, isString, allowNull, allowPercent) {
+    function getValue(node, name, isString, allowNull, allowPercent,
+            defaultValue) {
         // Interpret value as number. Never return NaN, but 0 instead.
         // If the value is a sequence of numbers, parseFloat will
         // return the first occurring number, which is enough for now.
-        var value = SvgElement.get(node, name),
+        var value = SvgElement.get(node, name) || defaultValue,
             res = value == null
                 ? allowNull
                     ? null
@@ -43,9 +44,9 @@ new function() {
             : res;
     }
 
-    function getPoint(node, x, y, allowNull, allowPercent) {
-        x = getValue(node, x || 'x', false, allowNull, allowPercent);
-        y = getValue(node, y || 'y', false, allowNull, allowPercent);
+    function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+        x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+        y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
         return allowNull && (x == null || y == null) ? null
                 : new Point(x, y);
     }
@@ -168,13 +169,16 @@ new function() {
                 'userSpaceOnUse';
         // Allow percentages in all values if scaleToBounds is true:
         if (radial) {
-            origin = getPoint(node, 'cx', 'cy', false, scaleToBounds);
+            origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+                '50%', '50%');
             destination = origin.add(
-                    getValue(node, 'r', false, false, scaleToBounds), 0);
+                getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
             highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
         } else {
-            origin = getPoint(node, 'x1', 'y1', false, scaleToBounds);
-            destination = getPoint(node, 'x2', 'y2', false, scaleToBounds);
+            origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+                '0%', '0%');
+            destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+                '100%', '0%');
         }
         var color = applyAttributes(
                 new Color(gradient, origin, destination, highlight), node);
diff --git a/test/assets/gradients-3.svg b/test/assets/gradients-3.svg
new file mode 100644
index 00000000..854ccf5a
--- /dev/null
+++ b/test/assets/gradients-3.svg
@@ -0,0 +1,17 @@
+<!-- test gradient default values -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="100" height="200">
+    <defs>
+        <!-- radial -->
+        <radialGradient id="gra-1">
+            <stop offset="0" stop-color="black"/>
+            <stop offset="1" stop-color="white"/>
+        </radialGradient>
+        <!-- linear -->
+        <linearGradient id="gra-2">
+            <stop offset="0" stop-color="black"/>
+            <stop offset="1" stop-color="white"/>
+        </linearGradient>
+    </defs>
+    <rect x="0" y="0" width="100" height="100" fill="url(#gra-1)"/>
+    <rect x="0" y="100" width="100" height="100" fill="url(#gra-2)"/>
+</svg>
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index fbd13ff2..b19aa95f 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -191,7 +191,8 @@ if (!isNode) {
         'symbol': {},
         'symbols': {},
         'blendModes': {},
-        'gradients-1': {}
+        'gradients-1': {},
+        'gradients-3': {}
     };
     // TODO: Investigate why Phantom struggles with this file:
     if (!isPhantom)

From 5cb93ec46e8f3845b8d270349eba934791cc134e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 14:06:35 +0200
Subject: [PATCH 075/181] Enable gradients-2 test in test:phantom
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It doesn't seem to struggle with it anymore….
---
 test/tests/SvgImport.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index b19aa95f..9fc7aa1f 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -192,11 +192,9 @@ if (!isNode) {
         'symbols': {},
         'blendModes': {},
         'gradients-1': {},
+        'gradients-2': {},
         'gradients-3': {}
     };
-    // TODO: Investigate why Phantom struggles with this file:
-    if (!isPhantom)
-        svgFiles['gradients-2'] = {};
     Base.each(svgFiles, function(options, name) {
         name += '.svg';
         test('Import ' + name, function(assert) {

From 1e2bbbdef22bef77be3ad25db03c980e9d54ebae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 14:34:32 +0200
Subject: [PATCH 076/181] Fix handling of native classes in tests again

Reverting breaking change in 10bdafa82685b011a571c0e75a9d763af9cde675
---
 src/load.js     |  6 ++++++
 test/helpers.js | 16 +++++++++-------
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/load.js b/src/load.js
index 2da037a9..d1f4dd7b 100644
--- a/src/load.js
+++ b/src/load.js
@@ -36,6 +36,12 @@ if (typeof window === 'object') {
         // the code the 2nd time around.
         load(root + 'src/load.js');
     } else {
+        // Some native javascript classes have name collisions with Paper.js
+        // classes. Store them to be able to use them later in tests.
+        this.nativeClasses = {
+            Event: window.Event,
+            MouseEvent: window.MouseEvent
+        };
         include('options.js');
         // Load constants.js, required by the on-the-fly preprocessing:
         include('constants.js');
diff --git a/test/helpers.js b/test/helpers.js
index 8e8fba2d..547922aa 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -35,10 +35,10 @@ if (isNode) {
 }
 
 // Some native javascript classes have name collisions with Paper.js classes.
-// Store them before `paper.install()` to be able to use them later in tests.
-var nativeClasses = {
-    Event: Event,
-    MouseEvent: MouseEvent
+// If they have not already been stored in `src/load.js`, do it now:
+var nativeClasses = this.nativeClasses || {
+    Event: this.Event || {},
+    MouseEvent: this.MouseEvent || {}
 };
 
 // The unit-tests expect the paper classes to be global.
@@ -678,10 +678,12 @@ var triggerMouseEvent = function(type, point, target) {
     target = target || (type === 'mousedown' ? view.element : document);
     // If `gulp load` was run, there is a name collision between paper Event /
     // MouseEvent and native javascript classes. In this case, we need to use
-    // native classes stored in global NativeClasses object instead.
+    // native classes stored in the nativeClasses object instead.
     // MouseEvent class does not exist in PhantomJS, so in that case, we need to
-    // use a polyfill method.
-    var MouseEvent = nativeClasses.MouseEvent || MouseEventPolyfill;
+    // use a polyfill method, see: https://stackoverflow.com/questions/42929639
+    var MouseEvent = typeof nativeClasses.MouseEvent === 'function'
+        ? nativeClasses.MouseEvent
+        : MouseEventPolyfill;
     var event = new MouseEvent(type, {
         bubbles: true,
         cancelable: true,

From 5a3cf624aa75c4e68b4d1659b26a587d01065091 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Thu, 6 Jun 2019 15:26:58 +0200
Subject: [PATCH 077/181] Fix importSVG() linear gradient x2 default values

---
 test/assets/gradients-4.svg | 9 +++++++++
 test/helpers.js             | 8 +++++---
 test/tests/SvgExport.js     | 2 +-
 test/tests/SvgImport.js     | 5 +++--
 test/tests/load.js          | 2 +-
 5 files changed, 19 insertions(+), 7 deletions(-)
 create mode 100644 test/assets/gradients-4.svg

diff --git a/test/assets/gradients-4.svg b/test/assets/gradients-4.svg
new file mode 100644
index 00000000..98fc5380
--- /dev/null
+++ b/test/assets/gradients-4.svg
@@ -0,0 +1,9 @@
+<svg x="0" y="0" width="300" height="300" version="1.1" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+        <linearGradient id="gradient" x1="0" y1="0" y2="300" gradientUnits="userSpaceOnUse">
+            <stop offset="0" stop-color="yellow"></stop>
+            <stop offset="1" stop-color="blue"></stop>
+        </linearGradient>
+    </defs>
+    <rect x="0" y="0" width="300" height="300" fill="url(#gradient)"></rect>
+</svg>
diff --git a/test/helpers.js b/test/helpers.js
index 547922aa..ceac3891 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -10,11 +10,13 @@
  * All rights reserved.
  */
 
-var isNode = typeof global === 'object',
+// We call our variable `isNodeContext` because resemblejs exposes a global
+// `isNode` function which would override it and break node check.
+var isNodeContext = typeof global === 'object',
     isPhantom = typeof window === 'object' && !!window.callPhantom,
     scope;
 
-if (isNode) {
+if (isNodeContext) {
     scope = global;
     // Resemble.js needs the Image constructor global.
     global.Image = paper.window.Image;
@@ -219,7 +221,7 @@ var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
         detail += diffDetail;
     }
     QUnit.push(ok, text, (100).toFixed(fixed) + '% identical');
-    if (!ok && result && !isNode) {
+    if (!ok && result && !isNodeContext) {
         // Get the right entry for this unit test and assertion, and
         // replace the results with images
         var entry = document.getElementById('qunit-test-output-' + id)
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index edcdd733..1ce8071e 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -119,7 +119,7 @@ test('Export SVG viewbox attribute with top left at origin', function() {
     equals(project.exportSVG({ bounds: rectangle }).getAttribute('viewBox'), '0,0,100,100');
 });
 
-if (!isNode) {
+if (!isNodeContext) {
     // JSDom does not have SVG rendering, so we can't test there.
     test('Export transformed shapes', function(assert) {
         var rect = new Shape.Rectangle({
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index 9fc7aa1f..140d30f1 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -181,7 +181,7 @@ function importSVG(assert, url, message, options) {
     });
 }
 
-if (!isNode) {
+if (!isNodeContext) {
     // JSDom does not have SVG rendering, so we can't test there.
     var svgFiles = {
         'butterfly': { tolerance: 1e-2 },
@@ -193,7 +193,8 @@ if (!isNode) {
         'blendModes': {},
         'gradients-1': {},
         'gradients-2': {},
-        'gradients-3': {}
+        'gradients-3': {},
+        'gradients-4': {}
     };
     Base.each(svgFiles, function(options, name) {
         name += '.svg';
diff --git a/test/tests/load.js b/test/tests/load.js
index 647e8e8c..5ceca1ce 100644
--- a/test/tests/load.js
+++ b/test/tests/load.js
@@ -64,6 +64,6 @@
 /*#*/ include('Numerical.js');
 
 // There is no need to test interactions in node context.
-if (!isNode) {
+if (!isNodeContext) {
     /*#*/ include('Interactions.js');
 }

From c5b304bb78e1c5084477e3e9eba061ccd63216e6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 14:57:02 +0200
Subject: [PATCH 078/181] Exclude gradients-2 test again on phantomjs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reverting 5cb93ec46e8f3845b8d270349eba934791cc134e 🤦‍♂️
The isNode() shenanigans was masking this issue
---
 test/helpers.js         |  4 ++--
 test/tests/SvgImport.js | 12 +++++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/test/helpers.js b/test/helpers.js
index ceac3891..cc8cabf5 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -10,10 +10,10 @@
  * All rights reserved.
  */
 
-// We call our variable `isNodeContext` because resemblejs exposes a global
+// We call our variable `isNodeContext` because resemble.js exposes a global
 // `isNode` function which would override it and break node check.
 var isNodeContext = typeof global === 'object',
-    isPhantom = typeof window === 'object' && !!window.callPhantom,
+    isPhantomContext = typeof window === 'object' && !!window.callPhantom,
     scope;
 
 if (isNodeContext) {
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index 140d30f1..a7dc2a48 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -192,15 +192,17 @@ if (!isNodeContext) {
         'symbols': {},
         'blendModes': {},
         'gradients-1': {},
-        'gradients-2': {},
+        'gradients-2': !isPhantomContext && {},
         'gradients-3': {},
         'gradients-4': {}
     };
     Base.each(svgFiles, function(options, name) {
-        name += '.svg';
-        test('Import ' + name, function(assert) {
-            importSVG(assert, 'assets/' + name, null, options);
-        });
+        if (options) {
+            name += '.svg';
+            test('Import ' + name, function(assert) {
+                importSVG(assert, 'assets/' + name, null, options);
+            });
+        }
     });
 
     test('Import inexistent file', function(assert) {

From eeb26436b0805022ab20dc3a869f6fb2b7965670 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Sat, 6 Oct 2018 15:37:44 +0200
Subject: [PATCH 079/181] Fix bounds error with nested empty items

Closes #1467
---
 src/item/Item.js    | 22 ++++++++++++++++++----
 test/tests/Group.js | 15 +++++++++++++++
 test/tests/Layer.js |  6 ++++++
 3 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 71448a25..dddb4068 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1072,7 +1072,9 @@ new function() { // Injection scope for various item event handlers
             options = options || {};
             for (var i = 0, l = items.length; i < l; i++) {
                 var item = items[i];
-                if (item._visible && !item.isEmpty()) {
+                // Item is handled if it is visible and not recursively empty.
+                // This avoid errors with nested empty groups (#1467).
+                if (item._visible && !item.isEmpty(true)) {
                     // Pass true for noInternal, since even when getting
                     // internal bounds for this item, we need to apply the
                     // matrices to its children.
@@ -2836,11 +2838,23 @@ new function() { // Injection scope for hit-test functions shared with project
      * no children, a {@link TextItem} with no text content and a {@link Path}
      * with no segments all are considered empty.
      *
-     * @return {Boolean}
+     * @param {Boolean} [recursively=false] whether an item with children should be
+     * considered empty if all its descendants are empty
+     * @return Boolean
      */
-    isEmpty: function() {
+    isEmpty: function(recursively) {
         var children = this._children;
-        return !children || !children.length;
+        var numChildren = children ? children.length : 0;
+        if (recursively) {
+            // In recursive check, item is empty if all its children are empty.
+            for (var i = 0; i < numChildren; i++) {
+                if (!children[i].isEmpty(recursively)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return !numChildren;
     },
 
     /**
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 52d7589d..17c59d06 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -151,3 +151,18 @@ test('group.setSelectedColor() with selected bound and position', function() {
     group2.selectedColor = 'black';
     comparePixels(group1, group2);
 });
+
+test('Group#isEmpty(recursively)', function() {
+    var group = new Group();
+    equals(true, group.isEmpty());
+    equals(true, group.isEmpty(true));
+    var group = new Group(new Group());
+    equals(false, group.isEmpty());
+    equals(true, group.isEmpty(true));
+    var group = new Group(new Path());
+    equals(false, group.isEmpty());
+    equals(true, group.isEmpty(true));
+    var group = new Group(new PointText());
+    equals(false, group.isEmpty());
+    equals(true, group.isEmpty(true));
+});
diff --git a/test/tests/Layer.js b/test/tests/Layer.js
index 2b73b52e..947f0ab4 100644
--- a/test/tests/Layer.js
+++ b/test/tests/Layer.js
@@ -139,3 +139,9 @@ test('#remove() with named layers', function(){
     equals(removeCount, 2,
             'project.layers[name].remove(); should be called twice');
 });
+
+test('#bounds with nested empty items', function() {
+    var item = new Path.Rectangle(new Point(10,10), new Size(10));
+    new Group(new Group());
+    equals(item.bounds, project.activeLayer.bounds);
+});

From 0eae0b6e4ddd024e40600abff115d0d2154ec3cd Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Mon, 5 Nov 2018 18:11:13 +0100
Subject: [PATCH 080/181] Prevent Item#importJSON() from overriding
 Item#insert()

Closes #1392
---
 CHANGELOG.md       |  1 +
 src/core/Base.js   | 10 +++++++++-
 test/tests/JSON.js |  7 +++++++
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 793e6bc6..128d08b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@
 
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
 - SVG Import: Fix gradient default values (#1632).
+- JSON Import: Prevent overriding `Item#insert()` (#1392).
 
 # `0.12.1`
 
diff --git a/src/core/Base.js b/src/core/Base.js
index dce8d049..acad821d 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -558,8 +558,16 @@ statics: /** @lends Base */{
                     if (args.length === 1 && obj instanceof Item
                             && (useTarget || !(obj instanceof Layer))) {
                         var arg = args[0];
-                        if (Base.isPlainObject(arg))
+                        if (Base.isPlainObject(arg)) {
                             arg.insert = false;
+                            // When using target, make sure the `item.insert()`
+                            // method is not overridden with the `arg.insert`
+                            // property that was just set. Pass an exclude
+                            // object to the call of `obj.set()` below (#1392).
+                            if (useTarget) {
+                                args = args.concat([{ insert: true }])
+                            }
+                        }
                     }
                     // When reusing an object, initialize it through #set()
                     // instead of the constructor function:
diff --git a/test/tests/JSON.js b/test/tests/JSON.js
index f8744224..656d63d2 100644
--- a/test/tests/JSON.js
+++ b/test/tests/JSON.js
@@ -256,3 +256,10 @@ test('Path#importJSON()', function() {
     equals(function() { return layer.firstChild === path; }, true);
     equals(function() { return path.parent === layer; }, true);
 });
+
+test('Item#importJSON() does not override Item#insert()', function() {
+    var path = new Path();
+    equals(typeof path.insert, 'function');
+    path.importJSON(path.exportJSON());
+    equals(typeof path.insert, 'function');
+});

From 25f2a0e77912cae3ea3b93c5741a0f2ef15cafc8 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 9 Nov 2018 10:26:54 +0100
Subject: [PATCH 081/181] Fix drawing with compound-paths as clip-items

Closes #1361
---
 CHANGELOG.md       |  1 +
 src/item/Item.js   |  6 ++++--
 test/tests/Item.js | 24 ++++++++++++++++++++++++
 3 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 128d08b7..13056b9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### Fixed
 
+- Fix drawing with compound path as clip item (#1361).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
 - SVG Import: Fix gradient default values (#1632).
 - JSON Import: Prevent overriding `Item#insert()` (#1392).
diff --git a/src/item/Item.js b/src/item/Item.js
index dddb4068..3b969fea 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4427,8 +4427,10 @@ new function() { // Injection scope for hit-test functions shared with project
         this._draw(ctx, param, viewMatrix, strokeMatrix);
         ctx.restore();
         matrices.pop();
-        if (param.clip && !param.dontFinish)
-            ctx.clip();
+        if (param.clip && !param.dontFinish) {
+            // Pass fill-rule to handle clipping with compound-paths (#1361).
+            ctx.clip(this.getFillRule());
+        }
         // If a temporary canvas was created, composite it onto the main canvas:
         if (!direct) {
             // Use BlendMode.process even for processing normal blendMode with
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 28242f69..0f751996 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -951,3 +951,27 @@ test('Item#rasterize() with empty bounds', function() {
     view.update();
     expect(0);
 });
+
+test('Item#draw() with CompoundPath as clip item', function() {
+    function createdClippedGroup(invertedOrder) {
+        var compound = new CompoundPath({
+            children: [
+                new Path.Circle(new Point(50, 50), 50),
+                new Path.Circle(new Point(100, 50), 50)
+            ],
+            fillRule: 'evenodd'
+        });
+
+        var rectangle = new Shape.Rectangle(new Point(0, 0), new Point(150, 50));
+
+        var group = new Group();
+        group.children = invertedOrder
+            ? [compound, rectangle]
+            : [rectangle, compound];
+        group.fillColor = 'black';
+        group.clipped = true;
+        return group;
+    };
+
+    comparePixels(createdClippedGroup(true), createdClippedGroup(false));
+});

From 5d14559116ac7aa3c109655259724fcfd6837823 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 16:54:15 +0200
Subject: [PATCH 082/181] Fix linting error and some minor cleanup

---
 CHANGELOG.md     | 10 +++++++---
 src/core/Base.js |  2 +-
 src/path/Path.js | 14 +++++++-------
 3 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13056b9e..257583d6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,10 +8,14 @@
 
 ### Fixed
 
-- Fix drawing with compound path as clip item (#1361).
+- Fix drawing with compound-paths as clip-items (#1361).
+- Fix drawing of path selection with small handle size (#1327).
+- Correctly calculate bounds with nested empty items (#1467).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
-- SVG Import: Fix gradient default values (#1632).
-- JSON Import: Prevent overriding `Item#insert()` (#1392).
+- SVG Export: Include missing viewBox attribute (#1576).
+- SVG Import: Use correct default values for gradients (#1632, #1661).
+- SVG Import: Add basic `<switch/>` support (#1597).
+- JSON Import: Prevent `Item#insert()` method from being overridden (#1392).
 
 # `0.12.1`
 
diff --git a/src/core/Base.js b/src/core/Base.js
index acad821d..52d963af 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -565,7 +565,7 @@ statics: /** @lends Base */{
                             // property that was just set. Pass an exclude
                             // object to the call of `obj.set()` below (#1392).
                             if (useTarget) {
-                                args = args.concat([{ insert: true }])
+                                args = args.concat([{ insert: true }]);
                             }
                         }
                     }
diff --git a/src/path/Path.js b/src/path/Path.js
index 353a7c14..22318354 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2174,11 +2174,11 @@ new function() { // Scope for drawing
 
     function drawHandles(ctx, segments, matrix, size) {
         // Only draw if size is not null or negative.
-        if (size <= 0) {
-            return;
-        }
+        if (size <= 0) return;
 
         var half = size / 2,
+            miniSize = size - 2,
+            miniHalf = half - 1,
             coords = new Array(6),
             pX, pY;
 
@@ -2208,12 +2208,12 @@ new function() { // Scope for drawing
                 drawHandle(4);
             // Draw a rectangle at segment.point:
             ctx.fillRect(pX - half, pY - half, size, size);
-            // If the point is not selected, draw a white square that is 1 px
-            // smaller on all sides. Only draw it if size is big enough (#1327).
-            if (!(selection & /*#=*/SegmentSelection.POINT) && size > 2) {
+            // If the point is not selected, draw a white square that is 1px
+            // smaller on all sides, but only draw it if size is big enough.
+            if (miniSize > 0 && !(selection & /*#=*/SegmentSelection.POINT)) {
                 var fillStyle = ctx.fillStyle;
                 ctx.fillStyle = '#ffffff';
-                ctx.fillRect(pX - half + 1, pY - half + 1, size - 2, size - 2);
+                ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
                 ctx.fillStyle = fillStyle;
             }
         }

From 06e0c4332574870683a0e2ed802337094d205cff Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 23 Nov 2018 15:22:47 +0100
Subject: [PATCH 083/181] Fix change propagation with colors on groups

Closes #1152
---
 src/style/Color.js  | 27 +++++++++++++++++++++++++++
 src/style/Style.js  |  6 ++++++
 test/tests/Color.js |  8 ++++++++
 3 files changed, 41 insertions(+)

diff --git a/src/style/Color.js b/src/style/Color.js
index 2e1d4a70..0a2ee035 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -1375,3 +1375,30 @@ new function() {
          */
     });
 });
+
+/**
+ * @name LinkedColor
+ *
+ * @class An internal version of Color that notifies its owner of each change
+ * through setting itself again on the setter that corresponds to the getter
+ * that produced this LinkedColor. This is used to solve group color update
+ * problem (#1152) with the same principle used in LinkedPoint.
+ *
+ * @private
+ */
+var LinkedColor = Color.extend({
+    // Make sure LinkedColor is displayed as Color in debugger.
+    initialize: function Color(color, item, setter) {
+        // Rely on real constructor for instantiation.
+        paper.Color.apply(this, [color]);
+        // Store references.
+        this._item = item;
+        this._setter = setter;
+    },
+
+    // Rely on Color#_changed() method to detect changes.
+    _changed: function(){
+        // Update owner color by calling setter.
+        this._item[this._setter](this);
+    }
+});
diff --git a/src/style/Style.js b/src/style/Style.js
index 5f868e82..5e6a4bf7 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -241,6 +241,12 @@ var Style = Base.extend(new function() {
                     }
                 }
             }
+            // Turn group related colors into LinkedColor instances that will
+            // allow calls like `group.fillColor.hue += 10` to be propagated to
+            // children.
+            if (owner instanceof Group && value instanceof Color) {
+                value = new LinkedColor(value, owner, set);
+            }
             return value;
         };
 
diff --git a/test/tests/Color.js b/test/tests/Color.js
index d8af1967..802bcb72 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -302,3 +302,11 @@ test('Gradients with applyMatrix', function() {
 
     comparePixels(path, shape);
 });
+
+test('LinkedColor for group colors', function() {
+    var item = new Group(new Path(), new Path());
+    item.strokeColor = 'red';
+    item.strokeColor.hue = 50;
+    item.strokeColor.hue = 100;
+    expect(0);
+});

From aca305981466aba72d4e0bee307d20e2a3f3a84d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 18:01:42 +0200
Subject: [PATCH 084/181] Move color owner handling directly to Color class

There was already Color#_owner, now there is Color#_setter too
---
 CHANGELOG.md              |  1 +
 src/style/Color.js        | 19 +++++++++++++++++--
 src/style/GradientStop.js | 10 ++++------
 src/style/Style.js        | 24 ++++++++++--------------
 test/helpers.js           |  4 ++--
 test/tests/Color.js       |  6 +++---
 6 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 257583d6..9f0ddee8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - Fix drawing with compound-paths as clip-items (#1361).
 - Fix drawing of path selection with small handle size (#1327).
 - Correctly calculate bounds with nested empty items (#1467).
+- Fix color change propagation on groups (#1152).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
 - SVG Export: Include missing viewBox attribute (#1576).
 - SVG Import: Use correct default values for gradients (#1632, #1661).
diff --git a/src/style/Color.js b/src/style/Color.js
index 0a2ee035..d751d824 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -711,8 +711,9 @@ var Color = Base.extend(new function() {
          */
         _changed: function() {
             this._canvasStyle = null;
-            if (this._owner)
-                this._owner._changed(/*#=*/Change.STYLE);
+            if (this._owner) {
+                this._owner[this._setter](this);
+            }
         },
 
         /**
@@ -1200,6 +1201,20 @@ var Color = Base.extend(new function() {
             random: function() {
                 var random = Math.random;
                 return new Color(random(), random(), random());
+            },
+
+            _setOwner: function(color, owner, setter) {
+                if (color) {
+                    // Clone color if owner changes:
+                    if (color._owner && owner && color._owner !== owner) {
+                        color = color.clone();
+                    }
+                    if (!color._owner ^ !owner) {
+                        color._owner = owner || null;
+                        color._setter = setter || null;
+                    }
+                }
+                return color;
             }
         }
     });
diff --git a/src/style/GradientStop.js b/src/style/GradientStop.js
index 72367d11..b1d2d427 100644
--- a/src/style/GradientStop.js
+++ b/src/style/GradientStop.js
@@ -175,12 +175,10 @@ var GradientStop = Base.extend(/** @lends GradientStop# */{
     },
 
     setColor: function(/* color */) {
-        // Make sure newly set colors are cloned, since they can only have
-        // one owner.
-        var color = Color.read(arguments, 0, { clone: true });
-        if (color)
-            color._owner = this;
-        this._color = color;
+        // Clear old color owner before setting new one:
+        Color._setOwner(this._color, null);
+        this._color = Color._setOwner(Color.read(arguments, 0), this,
+                'setColor');
         this._changed();
     },
 
diff --git a/src/style/Style.js b/src/style/Style.js
index 5e6a4bf7..ea27669b 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -180,17 +180,14 @@ var Style = Base.extend(new function() {
                     if (isColor) {
                         // The old value may be a native string or other color
                         // description that wasn't coerced to a color object yet
-                        if (old && old._owner !== undefined) {
-                            old._owner = undefined;
+                        if (old) {
+                            Color._setOwner(old, null);
                             old._canvasStyle = null;
                         }
                         if (value && value.constructor === Color) {
-                            // Clone color if it already has an owner.
                             // NOTE: If value is not a Color, it is only
                             // converted and cloned in the getter further down.
-                            if (value._owner)
-                                value = value.clone();
-                            value._owner = owner;
+                            value = Color._setOwner(value, owner, set);
                         }
                     }
                     // NOTE: We do not convert the values to Colors in the
@@ -216,8 +213,10 @@ var Style = Base.extend(new function() {
                 var value = this._values[key];
                 if (value === undefined) {
                     value = this._defaults[key];
-                    if (value && value.clone)
+                    // Clone defaults if available:
+                    if (value && value.clone) {
                         value = value.clone();
+                    }
                 } else {
                     var ctor = isColor ? Color : isPoint ? Point : null;
                     if (ctor && !(value && value.constructor === ctor)) {
@@ -225,8 +224,6 @@ var Style = Base.extend(new function() {
                         // conversion.
                         this._values[key] = value = ctor.read([value], 0,
                                 { readNull: true, clone: true });
-                        if (value && isColor)
-                            value._owner = owner;
                     }
                 }
             } else if (children) {
@@ -241,11 +238,10 @@ var Style = Base.extend(new function() {
                     }
                 }
             }
-            // Turn group related colors into LinkedColor instances that will
-            // allow calls like `group.fillColor.hue += 10` to be propagated to
-            // children.
-            if (owner instanceof Group && value instanceof Color) {
-                value = new LinkedColor(value, owner, set);
+            if (value && isColor) {
+                // Color._setOwner() may clone the color if it already has a
+                // different owner (e.g. resulting from `childValue` above):
+                value = Color._setOwner(value, owner, set);
             }
             return value;
         };
diff --git a/test/helpers.js b/test/helpers.js
index cc8cabf5..28e8be91 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -106,7 +106,7 @@ var equals = function(actual, expected, message, options) {
             || type === 'boolean' && 'Boolean'
             || type === 'undefined' && 'Undefined'
             || Array.isArray(expected) && 'Array'
-            || expected instanceof window.Element && 'Element' // handle DOM Elements
+            || expected instanceof window.Element && 'Element' // DOM Elements
             || (cls = expected && expected._class) // check _class 2nd last
             || type === 'object' && 'Object'; // Object as catch-all
     var comparator = type && comparators[type];
@@ -456,7 +456,7 @@ var comparators = {
             equals(actual.components, expected.components,
                     message + ' (#components)', options);
         } else {
-            QUnit.strictEqual(actual, expected, message);
+            QUnit.push(expected.equals(actual), actual, expected, message);
         }
     },
 
diff --git a/test/tests/Color.js b/test/tests/Color.js
index 802bcb72..363cdcc8 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -303,10 +303,10 @@ test('Gradients with applyMatrix', function() {
     comparePixels(path, shape);
 });
 
-test('LinkedColor for group colors', function() {
+test('Modifying group.strokeColor for multiple children', function() {
     var item = new Group(new Path(), new Path());
     item.strokeColor = 'red';
+    var strokeColor = item.strokeColor;
     item.strokeColor.hue = 50;
-    item.strokeColor.hue = 100;
-    expect(0);
+    equals(function() { return item.strokeColor !== undefined; }, true);
 });

From 80131f0398c4bf53063ee3c18035c51a4710fd8e Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 23 Nov 2018 11:54:42 +0100
Subject: [PATCH 085/181] Fix PaperScript#compile() with prefix operators

Closes #1611
---
 src/core/PaperScript.js   |  5 +++++
 test/tests/PaperScript.js | 20 ++++++++++++++++++++
 test/tests/load.js        |  2 ++
 3 files changed, 27 insertions(+)
 create mode 100644 test/tests/PaperScript.js

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index 00a40985..bdd8f4ab 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -268,6 +268,11 @@ Base.exports.PaperScript = function() {
                                 str = exp;
                             str = arg + '; ' + str;
                         }
+                        // If this is a prefixed update expression (++a / --a),
+                        // wrap expression in IIFE to avoid several bugs (#1450)
+                        if (node.prefix) {
+                            str = '(function(){return '+str+';})()';
+                        }
                         replaceCode(node, str);
                     } else { // AssignmentExpression
                         if (/^.=$/.test(node.operator)
diff --git a/test/tests/PaperScript.js b/test/tests/PaperScript.js
new file mode 100644
index 00000000..fc07f950
--- /dev/null
+++ b/test/tests/PaperScript.js
@@ -0,0 +1,20 @@
+/*
+ * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ */
+
+QUnit.module('PaperScript');
+
+test('PaperScript#compile() with prefix increment/decrement operators', function() {
+    var code = 'var x = 1; var y = 1 * --x;';
+    var compiled = PaperScript.compile(code, paper);
+    PaperScript.execute(compiled, paper);
+    expect(0);
+});
diff --git a/test/tests/load.js b/test/tests/load.js
index 5ceca1ce..a2546737 100644
--- a/test/tests/load.js
+++ b/test/tests/load.js
@@ -63,6 +63,8 @@
 
 /*#*/ include('Numerical.js');
 
+/*#*/ include('PaperScript.js');
+
 // There is no need to test interactions in node context.
 if (!isNodeContext) {
     /*#*/ include('Interactions.js');

From 4aa1bebf26ba954e7039cf89df6ff7b34d7b02de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 19:29:07 +0200
Subject: [PATCH 086/181] Improve handling of increment/decrement operators

Closes #1450
---
 CHANGELOG.md              |  1 +
 src/core/PaperScope.js    |  2 +-
 src/core/PaperScript.js   | 28 ++++++++++++++-------------
 test/tests/PaperScript.js | 40 +++++++++++++++++++++++++++++++++------
 4 files changed, 51 insertions(+), 20 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f0ddee8..c84e7c64 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,7 @@
 - SVG Import: Use correct default values for gradients (#1632, #1661).
 - SVG Import: Add basic `<switch/>` support (#1597).
 - JSON Import: Prevent `Item#insert()` method from being overridden (#1392).
+- PaperScript: Fix issues with increment/decrement operators (#1450, #1611).
 
 # `0.12.1`
 
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 4624b58a..fce42284 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -203,7 +203,7 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
      *     mapping, in case the code that's passed in has already been mingled.
      *
      * @param {String} code the PaperScript code
-     * @param {Object} [option] the compilation options
+     * @param {Object} [options] the compilation options
      */
     execute: function(code, options) {
 /*#*/   if (__options.paperScript) {
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index bdd8f4ab..d69560ad 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -127,7 +127,7 @@ Base.exports.PaperScript = function() {
      *     mapping, in case the code that's passed in has already been mingled.
      *
      * @param {String} code the PaperScript code
-     * @param {Object} [option] the compilation options
+     * @param {Object} [options] the compilation options
      * @return {Object} an object holding the compiled PaperScript translated
      *     into JavaScript code along with source-maps and other information.
      */
@@ -256,23 +256,25 @@ Base.exports.PaperScript = function() {
                             exp = '__$__(' + arg + ', "' + node.operator[0]
                                     + '", 1)',
                             str = arg + ' = ' + exp;
-                        // If this is not a prefixed update expression
-                        // (++a, --a), assign the old value before updating it.
-                        if (!node.prefix
-                                && (parentType === 'AssignmentExpression'
-                                    || parentType === 'VariableDeclarator')) {
-                            // Handle special issue #691 where the old value is
+                        if (node.prefix) {
+                            // A prefixed update expression (++a / --a),
+                            // wrap expression in paranthesis. See #1611
+                            str = '(' + str + ')';
+                        } else if (
+                            // A suffixed update expression (a++, a--),
+                            // assign the old value before updating it.
+                            // See #691, #1450
+                            parentType === 'AssignmentExpression' ||
+                            parentType === 'VariableDeclarator' ||
+                            parentType === 'BinaryExpression'
+                        ) {
+                            // Handle special case where the old value is
                             // assigned to itself, and the expression is just
                             // executed after, e.g.: `var x = ***; x = x++;`
                             if (getCode(parent.left || parent.id) === arg)
                                 str = exp;
                             str = arg + '; ' + str;
                         }
-                        // If this is a prefixed update expression (++a / --a),
-                        // wrap expression in IIFE to avoid several bugs (#1450)
-                        if (node.prefix) {
-                            str = '(function(){return '+str+';})()';
-                        }
                         replaceCode(node, str);
                     } else { // AssignmentExpression
                         if (/^.=$/.test(node.operator)
@@ -446,7 +448,7 @@ Base.exports.PaperScript = function() {
      *
      * @param {String} code the PaperScript code
      * @param {PaperScope} scope the scope for which the code is executed
-     * @param {Object} [option] the compilation options
+     * @param {Object} [options] the compilation options
      * @return {Object} the exports defined in the executed code
      */
     function execute(code, scope, options) {
diff --git a/test/tests/PaperScript.js b/test/tests/PaperScript.js
index fc07f950..1f2510c9 100644
--- a/test/tests/PaperScript.js
+++ b/test/tests/PaperScript.js
@@ -2,7 +2,7 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2016, Juerg Lehni & Jonathan Puckey
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
  * http://scratchdisk.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
@@ -12,9 +12,37 @@
 
 QUnit.module('PaperScript');
 
-test('PaperScript#compile() with prefix increment/decrement operators', function() {
-    var code = 'var x = 1; var y = 1 * --x;';
-    var compiled = PaperScript.compile(code, paper);
-    PaperScript.execute(compiled, paper);
-    expect(0);
+function executeCode(code, expected) {
+    try {
+        equals(PaperScript.execute(code, paper), expected, code);
+    } catch (err) {
+        ok(false, err + '');
+    }
+}
+
+test('PaperScript with prefix decrement operators', function() {
+    executeCode(
+        'var j = 0; for (var i = 10; i > 0; i--) { j++ }; module.exports = j',
+        10
+    );
+    executeCode(
+        'var x = 1; var y = 4 * --x; y; module.exports = x + " " + y',
+        '0 0'
+    );
+});
+
+test('PaperScript with suffix increment operators', function() {
+    executeCode(
+        'var j = 0; for (var i = 0; i < 10; ++i) { j++ }; module.exports = j',
+        10
+    );
+    // #691
+    executeCode(
+        'var x = 1; x = x++; module.exports = x',
+        1
+    );
+    executeCode(
+        'var x = 1; var y = 4 * x++; y; module.exports = x + " " + y',
+        '2 4'
+    );
 });

From e3c298d3f4602d0fffc652ababd45ed846da90d7 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Wed, 17 Oct 2018 10:11:35 +0200
Subject: [PATCH 087/181] Fix ignoring of clip item matrix in group internal
 bounds

Closes #1427
---
 src/item/Group.js   |  2 +-
 test/tests/Group.js | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/item/Group.js b/src/item/Group.js
index fd5083c0..8c66210d 100644
--- a/src/item/Group.js
+++ b/src/item/Group.js
@@ -172,7 +172,7 @@ var Group = Item.extend(/** @lends Group# */{
         var clipItem = this._getClipItem();
         return clipItem
             ? clipItem._getCachedBounds(
-                matrix && matrix.appended(clipItem._matrix),
+                matrix && matrix.appended(clipItem._matrix) || clipItem._matrix,
                 Base.set({}, options, { stroke: false }))
             : _getBounds.base.call(this, matrix, options);
     },
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 17c59d06..5ade1da8 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -166,3 +166,16 @@ test('Group#isEmpty(recursively)', function() {
     equals(false, group.isEmpty());
     equals(true, group.isEmpty(true));
 });
+
+test('group.getInternalBounds() with clip item without matrix applied', function() {
+    var point = new Point(100, 100);
+    var translation = new Point(100, 100);
+    var item = new Path.Circle({ center: point, radius: 50, fillColor: 'orange' });
+    var clip = new Path.Rectangle({ from: point.subtract(translation), to: point.add(translation) });
+    clip.applyMatrix = false;
+    clip.translate(translation);
+    var group = new Group(clip, item);
+    group.clipped = true;
+
+    equals(group.getInternalBounds(), new Rectangle(point, point.add(translation.multiply(2))));
+});

From 4ba406bfe3b1a158bf9826df837d4e42eaf7c264 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 9 Jun 2019 23:35:33 +0200
Subject: [PATCH 088/181] Streamline code for #1427

---
 CHANGELOG.md        |  1 +
 src/item/Group.js   |  3 +--
 test/tests/Group.js | 34 ++++++++++++++++++++++------------
 3 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c84e7c64..7b9ffd96 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@
 
 - Fix drawing with compound-paths as clip-items (#1361).
 - Fix drawing of path selection with small handle size (#1327).
+- Do not ignore `Group#clipItem.matrix` in `Group#internalBounds` (#1427).
 - Correctly calculate bounds with nested empty items (#1467).
 - Fix color change propagation on groups (#1152).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
diff --git a/src/item/Group.js b/src/item/Group.js
index 8c66210d..c3bd085c 100644
--- a/src/item/Group.js
+++ b/src/item/Group.js
@@ -171,8 +171,7 @@ var Group = Item.extend(/** @lends Group# */{
     _getBounds: function _getBounds(matrix, options) {
         var clipItem = this._getClipItem();
         return clipItem
-            ? clipItem._getCachedBounds(
-                matrix && matrix.appended(clipItem._matrix) || clipItem._matrix,
+            ? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
                 Base.set({}, options, { stroke: false }))
             : _getBounds.base.call(this, matrix, options);
     },
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 5ade1da8..e1e47153 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -167,15 +167,25 @@ test('Group#isEmpty(recursively)', function() {
     equals(true, group.isEmpty(true));
 });
 
-test('group.getInternalBounds() with clip item without matrix applied', function() {
-    var point = new Point(100, 100);
-    var translation = new Point(100, 100);
-    var item = new Path.Circle({ center: point, radius: 50, fillColor: 'orange' });
-    var clip = new Path.Rectangle({ from: point.subtract(translation), to: point.add(translation) });
-    clip.applyMatrix = false;
-    clip.translate(translation);
-    var group = new Group(clip, item);
-    group.clipped = true;
-
-    equals(group.getInternalBounds(), new Rectangle(point, point.add(translation.multiply(2))));
-});
+test(
+    'group.internalBounds with clip item without clip.applyMatrix = false',
+    function() {
+        var point = new Point(100, 100);
+        var translation = new Point(100, 100);
+        var item = new Path.Circle({
+            center: point,
+            radius: 50,
+            fillColor: 'orange'
+        });
+        var clip = new Path.Rectangle({
+            from: point.subtract(translation),
+            to: point.add(translation)
+        });
+        clip.applyMatrix = false;
+        clip.translate(translation);
+        var group = new Group(clip, item);
+        group.clipped = true;
+        var expected = new Rectangle(point, point.add(translation.multiply(2)));
+        equals(group.internalBounds, expected);
+    }
+);

From 3177c7ac4666552260124d57659846c4f18f7d61 Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Fri, 23 Nov 2018 11:04:45 +0100
Subject: [PATCH 089/181] Fix Path#arcTo() when from/to points are equal

Closes #1613
---
 CHANGELOG.md       |  1 +
 src/path/Path.js   | 81 ++++++++++++++++++++++++----------------------
 test/tests/Path.js |  8 +++++
 3 files changed, 51 insertions(+), 39 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7b9ffd96..57384e02 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 - Do not ignore `Group#clipItem.matrix` in `Group#internalBounds` (#1427).
 - Correctly calculate bounds with nested empty items (#1467).
 - Fix color change propagation on groups (#1152).
+- Fix `Path#arcTo()` where `from` and `to` points are equal (#1613).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
 - SVG Export: Include missing viewBox attribute (#1576).
 - SVG Import: Use correct default values for gradients (#1632, #1661).
diff --git a/src/path/Path.js b/src/path/Path.js
index 22318354..71454a0d 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2467,9 +2467,10 @@ new function() { // PostScript-style drawing commands
                 // #2: arcTo(through, to)
                 through = to;
                 to = Point.read(arguments);
-            } else {
+            } else if (!from.equals(to)) {
                 // #3: arcTo(to, radius, rotation, clockwise, large)
-                // Drawing arcs in SVG style:
+                // Draw arc in SVG style, but only if `from` and `to` are not
+                // equal (#1613).
                 var radius = Size.read(arguments),
                     isZero = Numerical.isZero;
                 // If rx = 0 or ry = 0 then this arc is treated as a
@@ -2565,47 +2566,49 @@ new function() { // PostScript-style drawing commands
                     extent += extent < 0 ? 360 : -360;
                 }
             }
-            var epsilon = /*#=*/Numerical.GEOMETRIC_EPSILON,
-                ext = abs(extent),
-                // Calculate the amount of segments required to approximate over
-                // `extend` degrees (extend / 90), but prevent ceil() from
-                // rounding up small imprecisions by subtracting epsilon first.
-                count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-                inc = extent / count,
-                half = inc * Math.PI / 360,
-                z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-                segments = [];
-            for (var i = 0; i <= count; i++) {
-                // Explicitly use to point for last segment, since depending
-                // on values the calculation adds imprecision:
-                var pt = to,
-                    out = null;
-                if (i < count) {
-                    out = vector.rotate(90).multiply(z);
-                    if (matrix) {
-                        pt = matrix._transformPoint(vector);
-                        out = matrix._transformPoint(vector.add(out))
-                                .subtract(pt);
+            if (extent) {
+                var epsilon = /*#=*/Numerical.GEOMETRIC_EPSILON,
+                    ext = abs(extent),
+                    // Calculate amount of segments required to approximate over
+                    // `extend` degrees (extend / 90), but prevent ceil() from
+                    // rounding up small imprecisions by subtracting epsilon.
+                    count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+                    inc = extent / count,
+                    half = inc * Math.PI / 360,
+                    z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+                    segments = [];
+                for (var i = 0; i <= count; i++) {
+                    // Explicitly use to point for last segment, since depending
+                    // on values the calculation adds imprecision:
+                    var pt = to,
+                        out = null;
+                    if (i < count) {
+                        out = vector.rotate(90).multiply(z);
+                        if (matrix) {
+                            pt = matrix._transformPoint(vector);
+                            out = matrix._transformPoint(vector.add(out))
+                                    .subtract(pt);
+                        } else {
+                            pt = center.add(vector);
+                        }
+                    }
+                    if (!i) {
+                        // Modify startSegment
+                        current.setHandleOut(out);
                     } else {
-                        pt = center.add(vector);
+                        // Add new Segment
+                        var _in = vector.rotate(-90).multiply(z);
+                        if (matrix) {
+                            _in = matrix._transformPoint(vector.add(_in))
+                                    .subtract(pt);
+                        }
+                        segments.push(new Segment(pt, _in, out));
                     }
+                    vector = vector.rotate(inc);
                 }
-                if (!i) {
-                    // Modify startSegment
-                    current.setHandleOut(out);
-                } else {
-                    // Add new Segment
-                    var _in = vector.rotate(-90).multiply(z);
-                    if (matrix) {
-                        _in = matrix._transformPoint(vector.add(_in))
-                                .subtract(pt);
-                    }
-                    segments.push(new Segment(pt, _in, out));
-                }
-                vector = vector.rotate(inc);
+                // Add all segments at once at the end for higher performance
+                this._add(segments);
             }
-            // Add all segments at once at the end for higher performance
-            this._add(segments);
         },
 
         lineBy: function(/* to */) {
diff --git a/test/tests/Path.js b/test/tests/Path.js
index 4fce91d9..47678d73 100644
--- a/test/tests/Path.js
+++ b/test/tests/Path.js
@@ -645,3 +645,11 @@ test('Path#arcTo(through, to) is on through point side (#1477)', function() {
     path.arcTo(p2, p3);
     equals(true, path.segments[1].point.x > p1.x);
 });
+
+test('Path#arcTo(to, radius, rotation, clockwise, large) when from and to are equal (#1613)', function(){
+    var point = new Point(10,10);
+    var path = new Path();
+    path.moveTo(point);
+    path.arcTo(point, new Size(10), 0, true, true);
+    expect(0);
+});

From cb3fd61b6f7416ed012d5572b0cc854e6c2c37ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 10 Jun 2019 00:04:16 +0200
Subject: [PATCH 090/181] Fix CHANGELOG heading hierarchy

---
 CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57384e02..99a76c2b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-# `prebuilt`
+## `prebuilt`
 
 ### Added
 
@@ -21,7 +21,7 @@
 - JSON Import: Prevent `Item#insert()` method from being overridden (#1392).
 - PaperScript: Fix issues with increment/decrement operators (#1450, #1611).
 
-# `0.12.1`
+## `0.12.1`
 
 ### Added
 

From 41094cd871334611c175c18a2317ab552c726b90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 10 Jun 2019 00:39:11 +0200
Subject: [PATCH 091/181] Change publish:packages task to publish in series

---
 gulp/tasks/publish.js | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 73d36d78..8d3166ec 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -82,11 +82,15 @@ gulp.task('publish:release', function() {
         .pipe(shell('npm publish'));
 });
 
-gulp.task('publish:packages',
-    packages.map(function(name) {
-        return 'publish:packages:' + name;
-    })
-);
+gulp.task('publish:packages', function() {
+    // Publish packages in series instead of in parallel, to see if this fixes
+    // recent issues with `npm publish`:
+    return run(
+        packages.map(function(name) {
+            return 'publish:packages:' + name;
+        })
+    );
+});
 
 packages.forEach(function(name) {
     gulp.task('publish:packages:' + name, ['publish:version'], function() {

From 44a7759219ec44db3afbf72948dec3cfecda007e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 10 Jun 2019 16:02:39 +0200
Subject: [PATCH 092/181] Fix Path._addBevelJoin() edge case

---
 src/path/Path.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/path/Path.js b/src/path/Path.js
index 71454a0d..5385e349 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2846,8 +2846,9 @@ statics: {
             normal1 = curve1.getNormalAtTime(1).multiply(radius)
                 .transform(strokeMatrix),
             normal2 = curve2.getNormalAtTime(0).multiply(radius)
-                .transform(strokeMatrix);
-        if (normal1.getDirectedAngle(normal2) < 0) {
+                .transform(strokeMatrix),
+                angle = normal1.getDirectedAngle(normal2);
+        if (angle < 0 || angle >= 180) {
             normal1 = normal1.negate();
             normal2 = normal2.negate();
         }

From 96a5d2bec73c7c92f31570eccfe06ee9e73cc2cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Mon, 10 Jun 2019 16:02:49 +0200
Subject: [PATCH 093/181] Some CHANGELOG cleanup

---
 CHANGELOG.md | 35 +++++++++++++++++++++++++----------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99a76c2b..afe2d040 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,10 +2,6 @@
 
 ## `prebuilt`
 
-### Added
-
-- Improve `new Raster(size[, position])` constructor (#1621).
-
 ### Fixed
 
 - Fix drawing with compound-paths as clip-items (#1361).
@@ -14,9 +10,10 @@
 - Correctly calculate bounds with nested empty items (#1467).
 - Fix color change propagation on groups (#1152).
 - Fix `Path#arcTo()` where `from` and `to` points are equal (#1613).
+- Improve `new Raster(size[, position])` constructor (#1621).
 - SVG Export: Fix error when `Item#matrix` is not invertible (#1580).
 - SVG Export: Include missing viewBox attribute (#1576).
-- SVG Import: Use correct default values for gradients (#1632, #1661).
+- SVG Import: Use correct default values for gradients (#1632, #1660).
 - SVG Import: Add basic `<switch/>` support (#1597).
 - JSON Import: Prevent `Item#insert()` method from being overridden (#1392).
 - PaperScript: Fix issues with increment/decrement operators (#1450, #1611).
@@ -126,6 +123,7 @@ the fixes and additions from the past two weeks:
 ## `0.11.5`
 
 ### Fixed
+
 - Fix `Curve#isSelected()` to correctly reflect the state of `#handle1` (#1378).
 - Key Events: Fix auto-filling issue on Chrome (#1358, #1365).
 - Boolean: Check that overlaps are on the right path (#1321).
@@ -138,38 +136,42 @@ the fixes and additions from the past two weeks:
 ## `0.11.4`
 
 ### Changed
+
 - Node.js: Add support for v8, and keep testing v4, v6, v7 in Travis CI.
 
 ## `0.11.3`
 
 ### Fixed
-- Mouse Events: Fix item-based `doubleclick` events (#1316).
 
+- Mouse Events: Fix item-based `doubleclick` events (#1316).
 - Overhaul the caching of bounds and matrix decomposition, improving reliability
   of `Item#rotation` and `#scaling` and fixing situations caused by wrongly
   caching `Item#position` and `#bounds` values.
-
 - Prevent consumed properties in object literal constructors from being set on
   the instance.
 
 ### Changed
+
 - Make all functions and accessors enumerable on all Paper.js classes.
 
 ## `0.11.2`
 
 ### Fixed
+
 - PaperScript: Fix a parsing error in math operations without white-space
   (#1314).
 
 ## `0.11.1`
 
 ### Fixed
+
 - Bring back deactivation of Node.js modules on browsers. This has most probably
   broken Webpack bundling in `0.11.0`.
 
 ## `0.11.0`
 
 ### Changed
+
 - Separate `paper` module on NPM into: `paper`, `paper-jsdom` and
  `paper-jsdom-canvas` (#1252):
     - `paper` is the main library, and can be used directly in a browser
@@ -182,12 +184,14 @@ the fixes and additions from the past two weeks:
       [jsdom](https://github.com/tmpvar/jsdom).
 
 ### Added
+
 - PaperScript: Support newer, external versions of Acorn.js for PaperScript
   parsing, opening the doors to ES 2015 (#1183, #1275).
 - Hit Tests: Implement `options.position` to hit `Item#position` (#1249).
 - Split `Item#copyTo()` into `#addTo()` and `#copyTo()`.
 
 ### Fixed
+
 - Intersections: Bring back special handling of curve end-points (#1284).
 - Intersections: Correctly handle `Item#applyMatrix = false` (#1289).
 - Boolean: Bring back on-path winding handling (#1281).
@@ -221,6 +225,7 @@ the fixes and additions from the past two weeks:
 ## `0.10.3`
 
 ### Changed
+
 - Node.js: Support v7, and keep testing v4 up to v7 in Travis CI.
 - Node.js: Loosely couple Node.js / Electron code to `Canvas` module, and treat
   its absence like a headless web worker context in the browser (#1103).
@@ -245,6 +250,7 @@ the fixes and additions from the past two weeks:
   `#reorient()` (#973).
 
 ### Added
+
 - Implement `Path#divideAt(location)`, in analogy to `Curve#divideAt(location)`.
 - Add `PathItem#compare()` as a way to compare the geometry of two paths to see
   if they describe the same shape, handling cases where paths start in different
@@ -263,6 +269,7 @@ the fixes and additions from the past two weeks:
   (#1004, #1177).
 
 ### Fixed
+
 - Many improvements to boolean operations:
     - Improve performance of boolean operations when there no actual crossings
       between the paths, but paths may be contained within each other.
@@ -303,17 +310,20 @@ the fixes and additions from the past two weeks:
   (#632).
 
 ### Removed
+
 - Remove `Numerical.TOLERANCE = 1e-6` as there is no internal use for it
   anymore.
 
 ## `0.10.2`
 
 ### Fixed
+
 - Get published version to work correctly in Bower again.
 
 ## `0.10.1`
 
 ### Fixed
+
 - Correct a few issues with documentation and NPM publishing that slipped
   through in the `0.10.0` release.
 
@@ -351,6 +361,7 @@ Thank you all for using Paper.js, submitting bugs and ideas, and all those that
 contribute to the code.
 
 ### Changed
+
 - Significant overhaul and improvements of boolean path operations
   `PathItem#unite()`, `#subtract()`, `#intersect()`, `#exclude()`, `#divide()`:
     - Improve handling of self-intersecting paths and non-zero fill-rules.
@@ -367,7 +378,7 @@ contribute to the code.
     - `Curve#getParameterAt(offset)` → `#getTimeAt(offset)`
     - `Curve#getParameterOf(point)` → `getTimeOf(point)`
     - `Curve#getPointAt(time, true)` → `#getPointAtTime(time)`
-    - `Curve#getTangentAt(time, true)` → `#getTangenttTime(time)`
+    - `Curve#getTangentAt(time, true)` → `#getTangentAtTime(time)`
     - `Curve#getNormalAt(time, true)` → `#getNormalAtTime(time)`
     - `Curve#getCurvatureAt(time, true)` → `#getCurvatureAtTime(time)`
     - `CurveLocation#parameter` → `#time`
@@ -427,6 +438,7 @@ contribute to the code.
   `Color` (#1043).
 
 ### Added
+
 - Use unified code-base for browsers, Node.js, Electron, and anything
   in-between, and enable npm install for browser use (#739).
 - Start using automatic code testing and deployment of prebuilt versions through
@@ -491,6 +503,7 @@ contribute to the code.
 - Add `Raster#loaded` to reflect the loading state of its image.
 
 ### Fixed
+
 - Fix calculations of `Item#strokeBounds` for all possible combinations of
   `Item#strokeScaling` and `Item#applyMatrix` for `Path`, `Shape` and
   `SymbolItem`, along with correct handling of such strokes in Item#hitTest()
@@ -569,10 +582,11 @@ contribute to the code.
   `Numerical.solveCubic()` for edge-cases (#1085).
 
 ### Removed
+
 - Canvas attributes "resize" and "data-paper-resize" no longer cause paper to
   resize the canvas when the viewport size changes; Additional CSS styles are
   required since `0.9.22`, e.g.:
-
+  
   ```css
   /* Scale canvas with resize attribute to full size */
   canvas[resize] {
@@ -587,6 +601,7 @@ contribute to the code.
   It is replaced by `Project#addLayer()` and `Project#insertLayer()`.
 
 ### Deprecated
+
 - `#windingRule` on `Item` and `Style` → `#fillRule`
 - `Curve#getNormalAt(time, true)` → `#getNormalAtTime(true)`
 - `Curve#divide()` → `#divideAt(offset)` / `#divideAtTime(time)`
@@ -594,7 +609,7 @@ contribute to the code.
 - `Curve#getParameterAt(offset)` → `#getTimeAt(offset)`
 - `Curve#getParameterOf(point)` → `getTimeOf(point)`
 - `Curve#getPointAt(time, true)` → `#getPointAtTime(time)`
-- `Curve#getTangentAt(time, true)` → `#getTangenttTime(time)`
+- `Curve#getTangentAt(time, true)` → `#getTangentAtTime(time)`
 - `Curve#getNormalAt(time, true)` → `#getNormalAtTime(time)`
 - `Curve#getCurvatureAt(time, true)` → `#getCurvatureAtTime(time)`
 - `CurveLocation#parameter` → `#time`

From f3e4c185fa8ef0564147c6a0feb26ac57ee8b782 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Tue, 11 Jun 2019 21:24:50 +0200
Subject: [PATCH 094/181] Fix code style

---
 examples/Node.js/Raster.js    | 2 +-
 examples/Node.js/SvgExport.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/Node.js/Raster.js b/examples/Node.js/Raster.js
index e3a28d68..0309ae03 100644
--- a/examples/Node.js/Raster.js
+++ b/examples/Node.js/Raster.js
@@ -24,7 +24,7 @@ raster.onLoad = function() {
     var fs = require('fs');
 
     var svg = new paper.XMLSerializer().serializeToString(project.exportSVG());
-    fs.writeFile(path.resolve('./out.svg'),svg, function (err) {
+    fs.writeFile(path.resolve('./out.svg'), svg, function (err) {
         if (err) throw err;
             console.log('Saved!');
     });
diff --git a/examples/Node.js/SvgExport.js b/examples/Node.js/SvgExport.js
index a0ae8365..5d9c236a 100644
--- a/examples/Node.js/SvgExport.js
+++ b/examples/Node.js/SvgExport.js
@@ -45,7 +45,7 @@ with (paper) {
     var svg = project.exportSVG({ asString: true });
     console.log(svg);
 
-    fs.writeFile(path.resolve('./out.svg'),svg, function (err) {
+    fs.writeFile(path.resolve('./out.svg'), svg, function (err) {
         if (err) throw err;
         console.log('Saved!');
     });

From 4857f1d73a22e62143a2c131f4773e10ab9e4b50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Tue, 11 Jun 2019 21:25:11 +0200
Subject: [PATCH 095/181] Change jsdom -> agent.node detection

---
 src/core/PaperScope.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index fce42284..28cd219d 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -95,7 +95,9 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
                                 /^(node|trident)$/.test(n) ? rv : v1;
                         agent.version = v;
                         agent.versionNumber = parseFloat(v);
-                        n = n === 'trident' ? 'msie' : n;
+                        n = n === 'trident' ? 'msie'
+                            : n === 'jsdom' ? 'node'
+                            : n;
                         agent.name = n;
                         agent[n] = true;
                     }
@@ -105,9 +107,6 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
                 delete agent.webkit;
             if (agent.atom)
                 delete agent.chrome;
-            // In Node.js, the user agent set by JSDOM no longer includes `node`
-            // but `jsdom` instead. Preserve `agent.node`:
-            agent.node = agent.jsdom;
         }
     },
 

From 0a56c7cef09f614f6c5e540049fa980a1ee78570 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Tue, 11 Jun 2019 21:28:22 +0200
Subject: [PATCH 096/181] No need to explicitly expose view

As it is enumerable on scope
---
 src/core/PaperScript.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index d69560ad..ca1f393e 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -491,7 +491,7 @@ Base.exports.PaperScript = function() {
                 }
             }
         }
-        expose({ __$__: __$__, $__: $__, paper: scope, view: view, tool: tool },
+        expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
                 true);
         expose(scope);
         // Add a fake `module.exports` object so PaperScripts can export things.

From 900a20795491c2d0893fba21409ab6bf05084db9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Tue, 11 Jun 2019 21:31:28 +0200
Subject: [PATCH 097/181] Simplify agent renaming

---
 src/core/PaperScope.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 28cd219d..1d066707 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -95,9 +95,7 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
                                 /^(node|trident)$/.test(n) ? rv : v1;
                         agent.version = v;
                         agent.versionNumber = parseFloat(v);
-                        n = n === 'trident' ? 'msie'
-                            : n === 'jsdom' ? 'node'
-                            : n;
+                        n = { trident: 'msie', jsdom: 'node' }[n] || n;
                         agent.name = n;
                         agent[n] = true;
                     }

From 3bce17815fcf27b934e84917cc42b21e36f44da4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 13 Jun 2019 23:36:52 +0200
Subject: [PATCH 098/181] Release version 0.12.2

---
 CHANGELOG.md                |     2 +-
 dist/paper-core.js          | 15334 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17082 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |    75 +-
 package.json                |     2 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 8 files changed, 32465 insertions(+), 36 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index afe2d040..eec55736 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## `prebuilt`
+## `0.12.2`
 
 ### Fixed
 
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..637429f5
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15333 @@
+/*!
+ * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Tue Jun 11 21:31:28 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.2",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				this._owner[this._setter](this);
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var LinkedColor = Color.extend({
+	initialize: function Color(color, item, setter) {
+		paper.Color.apply(this, [color]);
+		this._item = item;
+		this._setter = setter;
+	},
+
+	_changed: function(){
+		this._item[this._setter](this);
+	}
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner, set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..25d4b2cd
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17081 @@
+/*!
+ * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Tue Jun 11 21:31:28 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.2",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				this._owner[this._setter](this);
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var LinkedColor = Color.extend({
+	initialize: function Color(color, item, setter) {
+		paper.Color.apply(this, [color]);
+		this._item = item;
+		this._setter = setter;
+	},
+
+	_changed: function(){
+		this._item[this._setter](this);
+	}
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner, set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index e05fac73..981e2e34 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.1 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,7 +9,7 @@
  *
  * All rights reserved.
  *
- * Date: Thu Jun 6 00:04:28 2019 +0200
+ * Date: Tue Jun 11 21:31:28 2019 +0200
  *
  * This is an auto-generated type definition.
  */
@@ -2252,8 +2252,13 @@ declare module paper {
          * content is differs from type to type. For example, a {@link Group} with
          * no children, a {@link TextItem} with no text content and a {@link Path}
          * with no segments all are considered empty.
+         * 
+         * @param recursively - whether an item with children should be
+         * considered empty if all its descendants are empty
+         * 
+         * @return Boolean
          */
-        isEmpty(): boolean
+        isEmpty(recursively?: boolean): void
 
         /** 
          * Checks whether the item has a fill.
@@ -3299,9 +3304,9 @@ declare module paper {
          *     mapping, in case the code that's passed in has already been mingled.
          * 
          * @param code - the PaperScript code
-         * @param option - the compilation options
+         * @param options - the compilation options
          */
-        execute(code: string, option?: object): void
+        execute(code: string, options?: object): void
 
         /** 
          * Injects the paper scope into any other given scope. Can be used for
@@ -3352,12 +3357,12 @@ declare module paper {
          *     mapping, in case the code that's passed in has already been mingled.
          * 
          * @param code - the PaperScript code
-         * @param option - the compilation options
+         * @param options - the compilation options
          * 
          * @return an object holding the compiled PaperScript translated
          *     into JavaScript code along with source-maps and other information.
          */
-        static compile(code: string, option?: object): object
+        static compile(code: string, options?: object): object
 
         /** 
          * Compiles the PaperScript code into a compiled function and executes it.
@@ -3373,11 +3378,11 @@ declare module paper {
          * 
          * @param code - the PaperScript code
          * @param scope - the scope for which the code is executed
-         * @param option - the compilation options
+         * @param options - the compilation options
          * 
          * @return the exports defined in the executed code
          */
-        static execute(code: string, scope: PaperScope, option?: object): object
+        static execute(code: string, scope: PaperScope, options?: object): object
 
         /** 
          * Loads, compiles and executes PaperScript code in the HTML document. Note
@@ -5348,7 +5353,7 @@ declare module paper {
 
         /** 
          * Creates a new raster item from the passed argument, and places it in the
-         * active layer. `object` can either be a DOM Image, a Canvas, or a string
+         * active layer. `source` can either be a DOM Image, a Canvas, or a string
          * describing the URL to load the image from, or the ID of a DOM element to
          * get the image from (either a DOM Image or a Canvas).
          * 
@@ -5359,8 +5364,26 @@ declare module paper {
          */
         constructor(source?: HTMLImageElement | HTMLCanvasElement | string, position?: Point)
 
-        
-        setImageData(data: ImageData, point: Point): void
+        /** 
+         * Creates a new empty raster of the given size, and places it in the
+         * active layer.
+         * 
+         * @param size - the size of the raster
+         * @param position - the center position at which the raster item is
+         *     placed
+         */
+        constructor(size: Size, position?: Point)
+
+        /** 
+         * Extracts a part of the Raster's content as a sub image, and returns it as
+         * a Canvas object.
+         * 
+         * @param rect - the boundaries of the sub image in pixel
+         * coordinates
+         * 
+         * @return the sub image as a Canvas object
+         */
+        getSubCanvas(rect: Rectangle): HTMLCanvasElement
 
         /** 
          * Extracts a part of the raster item's content as a new raster item, placed
@@ -5396,26 +5419,18 @@ declare module paper {
          */
         getAverageColor(object: Path | Rectangle | Point): Color
 
+        
+        setImageData(data: ImageData, point: Point): void
+
         /** 
          * Gets the color of a pixel in the raster.
          * 
-         * @param x - the x offset of the pixel in pixel coordinates
-         * @param y - the y offset of the pixel in pixel coordinates
+         * @param point - the offset of the pixel as a point in pixel
+         *     coordinates
          * 
          * @return the color of the pixel
          */
-        getPixel(x: number, y: number): Color
-
-        /** 
-         * Extracts a part of the Raster's content as a sub image, and returns it as
-         * a Canvas object.
-         * 
-         * @param rect - the boundaries of the sub image in pixel
-         * coordinates
-         * 
-         * @return the sub image as a Canvas object
-         */
-        getSubCanvas(rect: Rectangle): HTMLCanvasElement
+        getPixel(point: Point): Color
 
         /** 
          * Sets the color of the specified pixel to the specified color.
@@ -5429,7 +5444,8 @@ declare module paper {
         /** 
          * Sets the color of the specified pixel to the specified color.
          * 
-         * @param point - the offset of the pixel as a point in pixel coordinates
+         * @param point - the offset of the pixel as a point in pixel
+         *     coordinates
          * @param color - the color that the pixel will be set to
          */
         setPixel(point: Point, color: Color): void
@@ -5448,11 +5464,12 @@ declare module paper {
         /** 
          * Gets the color of a pixel in the raster.
          * 
-         * @param point - the offset of the pixel as a point in pixel coordinates
+         * @param x - the x offset of the pixel in pixel coordinates
+         * @param y - the y offset of the pixel in pixel coordinates
          * 
          * @return the color of the pixel
          */
-        getPixel(point: Point): Color
+        getPixel(x: number, y: number): Color
 
     }
 
diff --git a/package.json b/package.json
index 1f03ac04..9813934f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 8d047809..f2bef583 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 8d04780979504ff54994e0af2726542c3be3bced
+Subproject commit f2bef5831a896ac98901a48516fd86393c0c2dd8
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index 1c9a5935..e47ff629 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit 1c9a593502d101d9802668c64163c33bdadbc229
+Subproject commit e47ff6292381cea0ad8cfe7c9ea96db5b02b0279
diff --git a/src/options.js b/src/options.js
index e92de00f..6741a55a 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.1';
+var version = '0.12.2';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From 91a7448c07bc72ad58e1b3fa9407566f2fd2a0f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 13 Jun 2019 23:43:50 +0200
Subject: [PATCH 099/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15334 +-------------------------------------
 dist/paper-full.js | 17082 +------------------------------------------
 2 files changed, 2 insertions(+), 32414 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 637429f5..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15333 +0,0 @@
-/*!
- * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Tue Jun 11 21:31:28 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.2",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				this._owner[this._setter](this);
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var LinkedColor = Color.extend({
-	initialize: function Color(color, item, setter) {
-		paper.Color.apply(this, [color]);
-		this._item = item;
-		this._setter = setter;
-	},
-
-	_changed: function(){
-		this._item[this._setter](this);
-	}
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner, set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index 25d4b2cd..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17081 +0,0 @@
-/*!
- * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Tue Jun 11 21:31:28 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.2",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				this._owner[this._setter](this);
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var LinkedColor = Color.extend({
-	initialize: function Color(color, item, setter) {
-		paper.Color.apply(this, [color]);
-		this._item = item;
-		this._setter = setter;
-	},
-
-	_changed: function(){
-		this._item[this._setter](this);
-	}
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner, set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From c04746aa000e347b688cbdace94973b4f1c80210 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Tue, 18 Jun 2019 06:15:20 +0200
Subject: [PATCH 100/181] Fix SVG export with Symbol (#1670)

Closes #1668
---
 src/svg/SvgExport.js    |  2 +-
 test/tests/SvgExport.js | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index fcd982a5..4b091158 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -182,7 +182,7 @@ new function() {
             definition = item._definition,
             node = getDefinition(definition, 'symbol'),
             definitionItem = definition._item,
-            bounds = definitionItem.getBounds();
+            bounds = definitionItem.getStrokeBounds();
         if (!node) {
             node = SvgElement.create('symbol', {
                 viewBox: formatter.rectangle(bounds)
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index 1ce8071e..a9b2ca62 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -229,4 +229,19 @@ if (!isNodeContext) {
             tolerance: 1e-2
         });
     });
+
+    test('Export symbol with stroke', function(assert) {
+        var item = new Path.Circle({
+            center: [0, 0],
+            radius: 50,
+            strokeColor: 'blue',
+            strokeWidth: 10
+        });
+
+        var symbol = new Symbol(item);
+        symbol.place([50, 50]);
+
+        var svg = project.exportSVG({ bounds: 'content', asString: true });
+        compareSVG(assert.async(), svg, project.activeLayer);
+    });
 }

From 7d457a866e2a7348e1ea5c25a20f49fb59775dbc Mon Sep 17 00:00:00 2001
From: Dobes Vandermeer <dobesv@gmail.com>
Date: Mon, 17 Jun 2019 21:16:46 -0700
Subject: [PATCH 101/181] Add docs for internalBounds (#1655)

---
 src/item/Item.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/item/Item.js b/src/item/Item.js
index 3b969fea..bdedfe39 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1119,6 +1119,17 @@ new function() { // Injection scope for various item event handlers
      * @type Rectangle
      */
 
+    /**
+     * The bounding rectangle of the item without any matrix transformations.
+     *
+     * Typical use case would be drawing a frame around the object where you
+     * want to draw something of the same size, position, rotation, and scaling,
+     * like a selection frame.
+     *
+     * @name Item#internalBounds
+     * @type Rectangle
+     */
+
     /**
      * The rough bounding rectangle of the item that is sure to include all of
      * the drawing, including stroke width.

From 55dbf010a8d2da0577a7b57d467ced3f611974e5 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Wed, 19 Jun 2019 21:56:44 +0200
Subject: [PATCH 102/181] Fix item.clipMask documentation (#1673)

Text items are not currently supported as clip masks.
---
 src/item/Item.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index bdedfe39..5a7fd3fc 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -658,8 +658,8 @@ new function() { // Injection scope for various item event handlers
 
     /**
      * Specifies whether the item defines a clip mask. This can only be set on
-     * paths, compound paths, and text frame objects, and only if the item is
-     * already contained within a clipping group.
+     * paths and compound paths, and only if the item is already contained
+     * within a clipping group.
      *
      * @bean
      * @type Boolean

From 32aff8e8957bfcd87d30135c4bb4a28a31cd7abe Mon Sep 17 00:00:00 2001
From: Dan Stucky <danfstucky@gmail.com>
Date: Wed, 19 Jun 2019 14:59:41 -0500
Subject: [PATCH 103/181] Handle non-invertible matrices in Item#contains()
 (#1651)

---
 src/item/Item.js   |  7 +++++--
 test/tests/Item.js | 19 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 5a7fd3fc..1a9d483a 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1816,8 +1816,11 @@ new function() { // Injection scope for various item event handlers
      */
     contains: function(/* point */) {
         // See CompoundPath#_contains() for the reason for !!
-        return !!this._contains(
-                this._matrix._inverseTransform(Point.read(arguments)));
+        var matrix = this._matrix;
+        return (
+            matrix.isInvertible() && 
+            !!this._contains(matrix._inverseTransform(Point.read(arguments)))
+        );
     },
 
     _contains: function(point) {
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 0f751996..d8b679a3 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -877,6 +877,25 @@ test('Item#pivot', function() {
             'Changing position of an item with applyMatrix = true should change pivot');
 });
 
+test('Item#contains', function() {
+    var point = new Point(50,50);
+    var path1 = new Path({matrix: new Matrix(0,0,0,0,0,0)});
+    
+    equals(path1.contains(point), false,
+            'An irregularly shaped item cannot contain a point');
+
+    var path2 = new Path.Rectangle({
+        point: [50, 50],
+        size: [100, 100]
+    });
+    equals(path2.contains(point), true,
+            'A regularly shaped item with a point inside it, contains that point');
+
+    var point2 = new Point(0,0);
+    equals(path2.contains(point2), false,
+            'A regularly shaped item with a point outside it, does not contain that point');
+});
+
 test('Item#position with irregular shape, #pivot and rotation', function() {
     var path1 = new Path([ [0, 0], [200, 100], [0, 100] ]);
     var path2 = path1.clone();

From b5c753f23d3c0b2f91a7b32eca9a453a563eceb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 19 Jun 2019 22:05:26 +0200
Subject: [PATCH 104/181] Improve test for #1651

Move to the right place and simplify to only test against a non-invertible matrix.
---
 test/tests/Item.js              | 19 -------------------
 test/tests/PathItem_Contains.js |  8 +++++++-
 2 files changed, 7 insertions(+), 20 deletions(-)

diff --git a/test/tests/Item.js b/test/tests/Item.js
index d8b679a3..0f751996 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -877,25 +877,6 @@ test('Item#pivot', function() {
             'Changing position of an item with applyMatrix = true should change pivot');
 });
 
-test('Item#contains', function() {
-    var point = new Point(50,50);
-    var path1 = new Path({matrix: new Matrix(0,0,0,0,0,0)});
-    
-    equals(path1.contains(point), false,
-            'An irregularly shaped item cannot contain a point');
-
-    var path2 = new Path.Rectangle({
-        point: [50, 50],
-        size: [100, 100]
-    });
-    equals(path2.contains(point), true,
-            'A regularly shaped item with a point inside it, contains that point');
-
-    var point2 = new Point(0,0);
-    equals(path2.contains(point2), false,
-            'A regularly shaped item with a point outside it, does not contain that point');
-});
-
 test('Item#position with irregular shape, #pivot and rotation', function() {
     var path1 = new Path([ [0, 0], [200, 100], [0, 100] ]);
     var path2 = path1.clone();
diff --git a/test/tests/PathItem_Contains.js b/test/tests/PathItem_Contains.js
index 34787374..4a07f48e 100644
--- a/test/tests/PathItem_Contains.js
+++ b/test/tests/PathItem_Contains.js
@@ -394,4 +394,10 @@ test('Path#contains() with Path#interiorPoint: #854, #1064', function() {
     }
 });
 
-
+test('IPathtem#contains() with non-invertible matrices (#1651)', function() {
+    var path = new Path({
+        matrix: new Matrix(0, 0, 0, 0, 0, 0)
+    });
+    equals(path.contains(path.position), false,
+            'A path with a non-invertible matrix cannot contain its position');
+});

From bc5a361470702c5a355f6ea747d3e83fa5bd6f71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 19 Jun 2019 22:44:54 +0200
Subject: [PATCH 105/181] Fix Color change propagation again

Closes #1672
---
 src/style/Color.js | 33 +++++----------------------------
 src/style/Style.js | 40 +++++++++++++++++++++++-----------------
 2 files changed, 28 insertions(+), 45 deletions(-)

diff --git a/src/style/Color.js b/src/style/Color.js
index d751d824..1c7f2e31 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -712,7 +712,11 @@ var Color = Base.extend(new function() {
         _changed: function() {
             this._canvasStyle = null;
             if (this._owner) {
-                this._owner[this._setter](this);
+                if (this._setter) {
+                    this._owner[this._setter](this);
+                } else {
+                    this._owner._changed(/*#=*/Change.STYLE);
+                }
             }
         },
 
@@ -1390,30 +1394,3 @@ new function() {
          */
     });
 });
-
-/**
- * @name LinkedColor
- *
- * @class An internal version of Color that notifies its owner of each change
- * through setting itself again on the setter that corresponds to the getter
- * that produced this LinkedColor. This is used to solve group color update
- * problem (#1152) with the same principle used in LinkedPoint.
- *
- * @private
- */
-var LinkedColor = Color.extend({
-    // Make sure LinkedColor is displayed as Color in debugger.
-    initialize: function Color(color, item, setter) {
-        // Rely on real constructor for instantiation.
-        paper.Color.apply(this, [color]);
-        // Store references.
-        this._item = item;
-        this._setter = setter;
-    },
-
-    // Rely on Color#_changed() method to detect changes.
-    _changed: function(){
-        // Update owner color by calling setter.
-        this._item[this._setter](this);
-    }
-});
diff --git a/src/style/Style.js b/src/style/Style.js
index ea27669b..b30e090a 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -187,7 +187,10 @@ var Style = Base.extend(new function() {
                         if (value && value.constructor === Color) {
                             // NOTE: If value is not a Color, it is only
                             // converted and cloned in the getter further down.
-                            value = Color._setOwner(value, owner, set);
+                            value = Color._setOwner(value, owner,
+                                    // Only provide a color-setter if the style
+                                    // is to be applied to the children:
+                                    applyToChildren && set);
                         }
                     }
                     // NOTE: We do not convert the values to Colors in the
@@ -204,12 +207,24 @@ var Style = Base.extend(new function() {
         fields[get] = function(_dontMerge) {
             var owner = this._owner,
                 children = owner && owner._children,
+                applyToChildren = children && children.length > 0
+                    && !(owner instanceof CompoundPath),
                 value;
             // If the owner has children, walk through all of them and see if
             // they all have the same style.
-            // If true is passed for _dontMerge, don't merge children styles
-            if (key in this._defaults && (!children || !children.length
-                    || _dontMerge || owner instanceof CompoundPath)) {
+            // If true is passed for _dontMerge, don't merge children styles.
+            if (applyToChildren && !_dontMerge) {
+                for (var i = 0, l = children.length; i < l; i++) {
+                    var childValue = children[i]._style[get]();
+                    if (!i) {
+                        value = childValue;
+                    } else if (!Base.equals(value, childValue)) {
+                        // If there is another child with a different
+                        // style, the style is not defined:
+                        return undefined;
+                    }
+                }
+            } else if (key in this._defaults) {
                 var value = this._values[key];
                 if (value === undefined) {
                     value = this._defaults[key];
@@ -226,22 +241,13 @@ var Style = Base.extend(new function() {
                                 { readNull: true, clone: true });
                     }
                 }
-            } else if (children) {
-                for (var i = 0, l = children.length; i < l; i++) {
-                    var childValue = children[i]._style[get]();
-                    if (!i) {
-                        value = childValue;
-                    } else if (!Base.equals(value, childValue)) {
-                        // If there is another child with a different
-                        // style, the style is not defined:
-                        return undefined;
-                    }
-                }
             }
             if (value && isColor) {
                 // Color._setOwner() may clone the color if it already has a
-                // different owner (e.g. resulting from `childValue` above):
-                value = Color._setOwner(value, owner, set);
+                // different owner (e.g. resulting from `childValue` above).
+                // Only provide a color-setter if the style is to be applied to
+                // the children:
+                value = Color._setOwner(value, owner, applyToChildren && set);
             }
             return value;
         };

From 6c6982b563f26ac4e222bb53c6beb26c1853962f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 13:01:22 +0200
Subject: [PATCH 106/181] Update CHANGELOG

---
 CHANGELOG.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eec55736..7a431291 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,18 @@
 # Change Log
 
+## `prebuilt`
+
+### Fixed
+
+- Fix regression in `Color` change propagation (#1672, #1674).
+- SVG Export: Fix viewport size of exported `Symbol` (#1668).
+- Handle non-invertible matrices in `Item#contains()` (#1651).
+- Improve documentation for `Item#clipMask` (#1673).
+
+### Added
+
+- Add documentation for `Item#internalBounds`.
+
 ## `0.12.2`
 
 ### Fixed

From 0b806e52dbce09cddf335cfbc61a397801c7b9cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 13:14:16 +0200
Subject: [PATCH 107/181] Another attempt at fixing publish task

I guess we'll find out shortly if it works
---
 gulp/tasks/publish.js | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 8d3166ec..c8efd534 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -32,7 +32,7 @@ var packages = ['paper-jsdom', 'paper-jsdom-canvas'],
         end_with_newline: true
     };
 
-gulp.task('publish', function() {
+gulp.task('publish', function(callback) {
     if (options.branch !== 'develop') {
         throw new Error('Publishing is only allowed on the develop branch.');
     }
@@ -45,7 +45,8 @@ gulp.task('publish', function() {
         'publish:commit',
         'publish:website',
         'publish:release',
-        'publish:load'
+        'publish:load',
+        callback
     );
 });
 
@@ -82,14 +83,14 @@ gulp.task('publish:release', function() {
         .pipe(shell('npm publish'));
 });
 
-gulp.task('publish:packages', function() {
+gulp.task('publish:packages', function(callback) {
     // Publish packages in series instead of in parallel, to see if this fixes
     // recent issues with `npm publish`:
-    return run(
-        packages.map(function(name) {
-            return 'publish:packages:' + name;
-        })
-    );
+    var args = packages.map(function(name) {
+        return 'publish:packages:' + name;
+    })
+    args.push(callback)
+    return run.call(this, args);
 });
 
 packages.forEach(function(name) {
@@ -112,11 +113,12 @@ packages.forEach(function(name) {
     });
 });
 
-gulp.task('publish:website', function() {
+gulp.task('publish:website', function(callback) {
     if (fs.lstatSync(sitePath).isDirectory()) {
         return run(
             'publish:website:build',
-            'publish:website:push'
+            'publish:website:push',
+            callback
         );
     }
 });

From e5d7bafd39db546e6c78bdbd89212c1685e05e1b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 13:40:19 +0200
Subject: [PATCH 108/181] Update JSDoc and add some minor doc changes

---
 gulp/jsdoc             | 2 +-
 src/basic/Matrix.js    | 2 +-
 src/basic/Point.js     | 2 +-
 src/basic/Rectangle.js | 2 +-
 src/basic/Size.js      | 2 +-
 src/style/Color.js     | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/gulp/jsdoc b/gulp/jsdoc
index da249447..e311a021 160000
--- a/gulp/jsdoc
+++ b/gulp/jsdoc
@@ -1 +1 @@
-Subproject commit da249447ca037b67cad8193c59e8ce33fb40c61f
+Subproject commit e311a021c10ff56b98cd95099485d44a29fab51b
diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index e4f84bf8..5ac409ab 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -104,7 +104,7 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * also work for calls of `set()`.
      *
      * @function
-     * @param {...*} value
+     * @param {...*} values
      * @return {Point}
      */
     set: '#initialize',
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 9af0c644..9765162a 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -170,7 +170,7 @@ var Point = Base.extend(/** @lends Point# */{
      * for calls of `set()`.
      *
      * @function
-     * @param {...*} value
+     * @param {...*} values
      * @return {Point}
      */
     set: '#initialize',
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index 5aab625d..09a388aa 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -159,7 +159,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * constructors also work for calls of `set()`.
      *
      * @function
-     * @param {...*} value
+     * @param {...*} values
      * @return {Rectangle}
      */
     set: '#initialize',
diff --git a/src/basic/Size.js b/src/basic/Size.js
index dad849b3..ba2e3f0b 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -130,7 +130,7 @@ var Size = Base.extend(/** @lends Size# */{
      * for calls of `set()`.
      *
      * @function
-     * @param {...*} value
+     * @param {...*} values
      * @return {Size}
      */
     set: '#initialize',
diff --git a/src/style/Color.js b/src/style/Color.js
index 1c7f2e31..6cf4d737 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -691,7 +691,7 @@ var Color = Base.extend(new function() {
          * constructors also work for calls of `set()`.
          *
          * @function
-         * @param {...*} value
+         * @param {...*} values
          * @return {Color}
          */
         set: '#initialize',

From b24e9b3835ab43a9d92780f771252130699cf4ad Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Sat, 22 Jun 2019 13:46:05 +0200
Subject: [PATCH 109/181] Fix typescript definition issues (#1669)

Closes #1667
Closes #1664
Closes #1663
Closes #1659
---
 dist/paper-full.js                            | 17082 +++++++++++++++-
 dist/paper.d.ts                               |   572 +-
 gulp/tasks/docs.js                            |     2 +-
 gulp/typescript/tsconfig.json                 |     9 +
 .../typescript-definition-generator.js        |    96 +-
 .../typescript-definition-template.mustache   |    15 +-
 gulp/typescript/typescript-definition-test.ts |    73 +-
 src/core/PaperScope.js                        |     1 +
 src/docs/global.js                            |     1 +
 src/path/Path.js                              |     8 +-
 10 files changed, 17564 insertions(+), 295 deletions(-)
 mode change 120000 => 100644 dist/paper-full.js
 create mode 100644 gulp/typescript/tsconfig.json

diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..d3acd9a4
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17081 @@
+/*!
+ * Paper.js v0.12.2-fix/typescript-definition-issues - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Fri Jun 14 15:03:35 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.2-fix/typescript-definition-issues",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		return !!this._contains(
+				this._matrix._inverseTransform(Point.read(arguments)));
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				this._owner[this._setter](this);
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var LinkedColor = Color.extend({
+	initialize: function Color(color, item, setter) {
+		paper.Color.apply(this, [color]);
+		this._item = item;
+		this._setter = setter;
+	},
+
+	_changed: function(){
+		this._item[this._setter](this);
+	}
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner, set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				value;
+			if (key in this._defaults && (!children || !children.length
+					|| _dontMerge || owner instanceof CompoundPath)) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			} else if (children) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-*/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 981e2e34..0f56d7a3 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.2 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.2-fix&#x2F;typescript-definition-issues - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,49 +9,105 @@
  *
  * All rights reserved.
  *
- * Date: Tue Jun 11 21:31:28 2019 +0200
+ * Date: Fri Jun 14 15:03:35 2019 +0200
  *
  * This is an auto-generated type definition.
  */
 
 declare module paper {
     /** 
-     * The project for which the PaperScript is executed.
-     * 
-     * Note that when working with multiple projects, this does not necessarily
-     * reflect the currently active project. For this, use
-     * {@link PaperScope#project} instead.
+     * The version of Paper.js, as a string.
      */
-    let project: Project
+    let version: string
+
+    /** 
+     * Gives access to paper's configurable settings.
+     * 
+     * @option [settings.insertItems=true] {Boolean} controls whether newly
+     *     created items are automatically inserted into the scene graph, by
+     *     adding them to {@link Project#activeLayer}
+     * @option [settings.applyMatrix=true] {Boolean} controls what value newly
+     *     created items have their {@link Item#applyMatrix} property set to
+     *     (Note that not all items can set this to `false`)
+     * @option [settings.handleSize=4] {Number} the size of the curve handles
+     *     when drawing selections
+     * @option [settings.hitTolerance=0] {Number} the default tolerance for hit-
+     *     tests, when no value is specified
+     */
+    let settings: any
+
+    /** 
+     * The currently active project.
+     */
+    let project: Project | null
 
     /** 
      * The list of all open projects within the current Paper.js context.
      */
-    let projects: Project[]
+    let projects: Project[] | null
 
     /** 
-     * The reference to the project's view.
-     * 
-     * Note that when working with multiple projects, this does not necessarily
-     * reflect the view of the currently active project. For this, use
-     * {@link PaperScope#view} instead.
+     * The reference to the active project's view.
      */
     let view: View
 
     /** 
-     * The reference to the tool object which is automatically created when global
-     * tool event handlers are defined.
-     * 
-     * Note that when working with multiple tools, this does not necessarily
-     * reflect the currently active tool. For this, use {@link PaperScope#tool}
-     * instead.
+     * The reference to the active tool.
      */
-    let tool: Tool
+    let tool: Tool | null
 
     /** 
      * The list of available tools.
      */
-    let tools: Tool[]
+    let tools: Tool[] | null
+
+
+    /** 
+     * Compiles the PaperScript code into a compiled function and executes it.
+     * The compiled function receives all properties of this {@link PaperScope}
+     * as arguments, to emulate a global scope with unaffected performance. It
+     * also installs global view and tool handlers automatically on the
+     * respective objects.
+     * 
+     * @option options.url {String} the url of the source, for source-map
+     *     debugging
+     * @option options.source {String} the source to be used for the source-
+     *     mapping, in case the code that's passed in has already been mingled.
+     * 
+     * @param code - the PaperScript code
+     * @param options - the compilation options
+     */
+    function execute(code: string, options?: object): void
+
+    /** 
+     * Injects the paper scope into any other given scope. Can be used for
+     * example to inject the currently active PaperScope into the window's
+     * global scope, to emulate PaperScript-style globally accessible Paper
+     * classes and objects.
+     * 
+     * <b>Please note:</b> Using this method may override native constructors
+     * (e.g. Path). This may cause problems when using Paper.js in conjunction
+     * with other libraries that rely on these constructors. Keep the library
+     * scoped if you encounter issues caused by this.
+     */
+    function install(scope: any): void
+
+    /** 
+     * Sets up an empty project for us. If a canvas is provided, it also creates
+     * a {@link View} for it, both linked to this scope.
+     * 
+     * @param element - the HTML canvas element
+     * this scope should be associated with, or an ID string by which to find
+     * the element, or the size of the canvas to be created for usage in a web
+     * worker.
+     */
+    function setup(element: HTMLCanvasElement | string | Size): void
+
+    /** 
+     * Activates this PaperScope, so all newly created items will be placed
+     * in its active project.
+     */
+    function activate(): void
 
 
 
@@ -65,7 +121,7 @@ declare module paper {
         /** 
          * The type of the color as a string.
          */
-        type: string
+        type: string | null
 
         /** 
          * The color components that define the color, including the alpha value
@@ -77,59 +133,59 @@ declare module paper {
          * The color's alpha value as a number between `0` and `1`.
          * All colors of the different subclasses support alpha values.
          */
-        alpha: number
+        alpha: number | null
 
         /** 
          * The amount of red in the color as a value between `0` and `1`.
          */
-        red: number
+        red: number | null
 
         /** 
          * The amount of green in the color as a value between `0` and `1`.
          */
-        green: number
+        green: number | null
 
         /** 
          * The amount of blue in the color as a value between `0` and `1`.
          */
-        blue: number
+        blue: number | null
 
         /** 
          * The amount of gray in the color as a value between `0` and `1`.
          */
-        gray: number
+        gray: number | null
 
         /** 
          * The hue of the color as a value in degrees between `0` and `360`.
          */
-        hue: number
+        hue: number | null
 
         /** 
          * The saturation of the color as a value between `0` and `1`.
          */
-        saturation: number
+        saturation: number | null
 
         /** 
          * The brightness of the color as a value between `0` and `1`.
          */
-        brightness: number
+        brightness: number | null
 
         /** 
          * The lightness of the color as a value between `0` and `1`.
          * 
          * Note that all other components are shared with HSB.
          */
-        lightness: number
+        lightness: number | null
 
         /** 
          * The gradient object describing the type of gradient and the stops.
          */
-        gradient: Gradient
+        gradient: Gradient | null
 
         /** 
          * The highlight point of the gradient.
          */
-        highlight: Point
+        highlight: Point | null
 
 
         /** 
@@ -390,7 +446,7 @@ declare module paper {
          * 
          * @see Path#closed
          */
-        closed: boolean
+        closed: boolean | null
 
         /** 
          * The first Segment contained within the compound-path, a short-cut to
@@ -473,22 +529,22 @@ declare module paper {
         /** 
          * The first anchor point of the curve.
          */
-        point1: Point
+        point1: Point | null
 
         /** 
          * The second anchor point of the curve.
          */
-        point2: Point
+        point2: Point | null
 
         /** 
          * The handle point that describes the tangent in the first anchor point.
          */
-        handle1: Point
+        handle1: Point | null
 
         /** 
          * The handle point that describes the tangent in the second anchor point.
          */
-        handle2: Point
+        handle2: Point | null
 
         /** 
          * The first segment of the curve.
@@ -525,7 +581,7 @@ declare module paper {
         /** 
          * Specifies whether the points and handles of the curve are selected.
          */
-        selected: boolean
+        selected: boolean | null
 
         /** 
          * An array of 8 float values, describing this curve's geometry in four
@@ -558,17 +614,17 @@ declare module paper {
         /** 
          * The bounding rectangle of the curve excluding stroke width.
          */
-        bounds: Rectangle
+        bounds: Rectangle | null
 
         /** 
          * The bounding rectangle of the curve including stroke width.
          */
-        strokeBounds: Rectangle
+        strokeBounds: Rectangle | null
 
         /** 
          * The bounding rectangle of the curve including handles.
          */
-        handleBounds: Rectangle
+        handleBounds: Rectangle | null
 
 
         /** 
@@ -1189,7 +1245,7 @@ declare module paper {
          * 
          * @see Key.modifiers
          */
-        readonly modifiers: object
+        readonly modifiers: any
 
 
         /** 
@@ -1222,12 +1278,12 @@ declare module paper {
         /** 
          * The gradient stops on the gradient ramp.
          */
-        stops: GradientStop[]
+        stops: GradientStop[] | null
 
         /** 
          * Specifies whether the gradient is radial or linear.
          */
-        radial: boolean
+        radial: boolean | null
 
 
         /** 
@@ -1251,12 +1307,12 @@ declare module paper {
         /** 
          * The ramp-point of the gradient stop as a value between `0` and `1`.
          */
-        offset: number
+        offset: number | null
 
         /** 
          * The color of the gradient stop.
          */
-        color: Color
+        color: Color | null
 
 
         /** 
@@ -1287,7 +1343,7 @@ declare module paper {
          * `true`, the first child in the group is automatically defined as the
          * clipping mask.
          */
-        clipped: boolean
+        clipped: boolean | null
 
 
         /** 
@@ -1318,43 +1374,43 @@ declare module paper {
          * Describes the type of the hit result. For example, if you hit a segment
          * point, the type would be `'segment'`.
          */
-        type: string
+        type: string | null
 
         /** 
          * If the HitResult has a {@link HitResult#type} of `'bounds'`, this
          * property describes which corner of the bounding rectangle was hit.
          */
-        name: string
+        name: string | null
 
         /** 
          * The item that was hit.
          */
-        item: Item
+        item: Item | null
 
         /** 
          * If the HitResult has a type of 'curve' or 'stroke', this property gives
          * more information about the exact position that was hit on the path.
          */
-        location: CurveLocation
+        location: CurveLocation | null
 
         /** 
          * If the HitResult has a type of 'pixel', this property refers to the color
          * of the pixel on the {@link Raster} that was hit.
          */
-        color: Color
+        color: Color | null
 
         /** 
          * If the HitResult has a type of 'stroke', 'segment', 'handle-in' or
          * 'handle-out', this property refers to the segment that was hit or that
          * is closest to the hitResult.location on the curve.
          */
-        segment: Segment
+        segment: Segment | null
 
         /** 
          * Describes the actual coordinates of the segment, handle or bounding box
          * corner that was hit.
          */
-        point: Point
+        point: Point | null
 
 
     }
@@ -1376,30 +1432,30 @@ declare module paper {
         /** 
          * The class name of the item as a string.
          */
-        className: string
+        className: string | null
 
         /** 
          * The name of the item. If the item has a name, it can be accessed by name
          * through its parent's children list.
          */
-        name: string
+        name: string | null
 
         /** 
          * The path style of the item.
          */
-        style: Style
+        style: Style | null
 
         /** 
          * Specifies whether the item is locked. When set to `true`, item
          * interactions with the mouse are disabled.
          */
-        locked: boolean
+        locked: boolean | null
 
         /** 
          * Specifies whether the item is visible. When set to `false`, the item
          * won't be drawn.
          */
-        visible: boolean
+        visible: boolean | null
 
         /** 
          * The blend mode with which the item is composited onto the canvas. Both
@@ -1407,12 +1463,12 @@ declare module paper {
          * are supported. If blend-modes cannot be rendered natively, they are
          * emulated. Be aware that emulation can have an impact on performance.
          */
-        blendMode: string
+        blendMode: string | null
 
         /** 
          * The opacity of the item as a value between `0` and `1`.
          */
-        opacity: number
+        opacity: number | null
 
         /** 
          * Specifies whether the item is selected. This will also return `true` for
@@ -1429,27 +1485,27 @@ declare module paper {
          * @see Curve#selected
          * @see Point#selected
          */
-        selected: boolean
+        selected: boolean | null
 
         /** 
          * Specifies whether the item defines a clip mask. This can only be set on
          * paths, compound paths, and text frame objects, and only if the item is
          * already contained within a clipping group.
          */
-        clipMask: boolean
+        clipMask: boolean | null
 
         /** 
          * A plain javascript object which can be used to store
          * arbitrary data on the item.
          */
-        data: object
+        data: any
 
         /** 
          * The item's position within the parent item's coordinate system. By
          * default, this is the {@link Rectangle#center} of the item's
          * {@link #bounds} rectangle.
          */
-        position: Point
+        position: Point | null
 
         /** 
          * The item's pivot point specified in the item coordinate system, defining
@@ -1458,22 +1514,22 @@ declare module paper {
          * meaning the {@link Rectangle#center} of the item's {@link #bounds}
          * rectangle is used as pivot.
          */
-        pivot: Point
+        pivot: Point | null
 
         /** 
          * The bounding rectangle of the item excluding stroke width.
          */
-        bounds: Rectangle
+        bounds: Rectangle | null
 
         /** 
          * The bounding rectangle of the item including stroke width.
          */
-        strokeBounds: Rectangle
+        strokeBounds: Rectangle | null
 
         /** 
          * The bounding rectangle of the item including handles.
          */
-        handleBounds: Rectangle
+        handleBounds: Rectangle | null
 
         /** 
          * The current rotation angle of the item, as described by its
@@ -1482,7 +1538,7 @@ declare module paper {
          * {@link #applyMatrix} set to `false`, meaning they do not directly bake
          * transformations into their content.
          */
-        rotation: number
+        rotation: number | null
 
         /** 
          * The current scale factor of the item, as described by its
@@ -1491,13 +1547,13 @@ declare module paper {
          * {@link #applyMatrix} set to `false`, meaning they do not directly bake
          * transformations into their content.
          */
-        scaling: Point
+        scaling: Point | null
 
         /** 
          * The item's transformation matrix, defining position and dimensions in
          * relation to its parent item in which it is contained.
          */
-        matrix: Matrix
+        matrix: Matrix | null
 
         /** 
          * The item's global transformation matrix in relation to the global project
@@ -1521,7 +1577,7 @@ declare module paper {
          * on to the segments in {@link Path} items, the children of {@link Group}
          * items, etc.).
          */
-        applyMatrix: boolean
+        applyMatrix: boolean | null
 
         /** 
          * The project that this item belongs to.
@@ -1541,7 +1597,7 @@ declare module paper {
         /** 
          * The item that this item is contained within.
          */
-        parent: Item
+        parent: Item | null
 
         /** 
          * The children items contained within this item. Items that define a
@@ -1553,7 +1609,7 @@ declare module paper {
          * {@link Item#removeChildren}. To add items to the children list, use
          * {@link Item#addChild} or {@link Item#insertChild}.
          */
-        children: Item[]
+        children: Item[] | null
 
         /** 
          * The first item contained within this item. This is a shortcut for
@@ -1585,41 +1641,41 @@ declare module paper {
         /** 
          * The color of the stroke.
          */
-        strokeColor: Color
+        strokeColor: Color | null
 
         /** 
          * The width of the stroke.
          */
-        strokeWidth: number
+        strokeWidth: number | null
 
         /** 
          * The shape to be used at the beginning and end of open {@link Path} items,
          * when they have a stroke.
          */
-        strokeCap: string
+        strokeCap: string | null
 
         /** 
          * The shape to be used at the segments and corners of {@link Path} items
          * when they have a stroke.
          */
-        strokeJoin: string
+        strokeJoin: string | null
 
         /** 
          * The dash offset of the stroke.
          */
-        dashOffset: number
+        dashOffset: number | null
 
         /** 
          * Specifies whether the stroke is to be drawn taking the current affine
          * transformation into account (the default behavior), or whether it should
          * appear as a non-scaling stroke.
          */
-        strokeScaling: boolean
+        strokeScaling: boolean | null
 
         /** 
          * Specifies an array containing the dash and gap lengths of the stroke.
          */
-        dashArray: number[]
+        dashArray: number[] | null
 
         /** 
          * The miter limit of the stroke.
@@ -1629,39 +1685,39 @@ declare module paper {
          * miterLimit imposes a limit on the ratio of the miter length to the
          * {@link Item#strokeWidth}.
          */
-        miterLimit: number
+        miterLimit: number | null
 
         /** 
          * The fill color of the item.
          */
-        fillColor: Color
+        fillColor: Color | null
 
         /** 
          * The fill-rule with which the shape gets filled. Please note that only
          * modern browsers support fill-rules other than `'nonzero'`.
          */
-        fillRule: string
+        fillRule: string | null
 
         /** 
          * The shadow color.
          */
-        shadowColor: Color
+        shadowColor: Color | null
 
         /** 
          * The shadow's blur radius.
          */
-        shadowBlur: number
+        shadowBlur: number | null
 
         /** 
          * The shadow's offset.
          */
-        shadowOffset: Point
+        shadowOffset: Point | null
 
         /** 
          * The color the item is highlighted with when selected. If the item does
          * not specify its own color, the color defined by its layer is used instead.
          */
-        selectedColor: Color
+        selectedColor: Color | null
 
         /** 
          * Item level handler function to be called on each frame of an animation.
@@ -1677,7 +1733,7 @@ declare module paper {
          * @option event.delta {Number} the time passed in seconds since the last
          *     frame event
          */
-        onFrame: Function
+        onFrame: Function | null
 
         /** 
          * The function to be called when the mouse button is pushed down on the
@@ -1689,7 +1745,7 @@ declare module paper {
          * 
          * @see View#onMouseDown
          */
-        onMouseDown: Function
+        onMouseDown: Function | null
 
         /** 
          * The function to be called when the mouse position changes while the mouse
@@ -1701,7 +1757,7 @@ declare module paper {
          * 
          * @see View#onMouseDrag
          */
-        onMouseDrag: Function
+        onMouseDrag: Function | null
 
         /** 
          * The function to be called when the mouse button is released over the item.
@@ -1713,7 +1769,7 @@ declare module paper {
          * 
          * @see View#onMouseUp
          */
-        onMouseUp: Function
+        onMouseUp: Function | null
 
         /** 
          * The function to be called when the mouse clicks on the item. The function
@@ -1725,7 +1781,7 @@ declare module paper {
          * 
          * @see View#onClick
          */
-        onClick: Function
+        onClick: Function | null
 
         /** 
          * The function to be called when the mouse double clicks on the item. The
@@ -1737,7 +1793,7 @@ declare module paper {
          * 
          * @see View#onDoubleClick
          */
-        onDoubleClick: Function
+        onDoubleClick: Function | null
 
         /** 
          * The function to be called repeatedly while the mouse moves over the item.
@@ -1749,7 +1805,7 @@ declare module paper {
          * 
          * @see View#onMouseMove
          */
-        onMouseMove: Function
+        onMouseMove: Function | null
 
         /** 
          * The function to be called when the mouse moves over the item. This
@@ -1762,7 +1818,7 @@ declare module paper {
          * 
          * @see View#onMouseEnter
          */
-        onMouseEnter: Function
+        onMouseEnter: Function | null
 
         /** 
          * The function to be called when the mouse moves out of the item.
@@ -1774,7 +1830,7 @@ declare module paper {
          * 
          * @see View#onMouseLeave
          */
-        onMouseLeave: Function
+        onMouseLeave: Function | null
 
 
         /** 
@@ -2694,7 +2750,7 @@ declare module paper {
          * @option modifiers.command {Boolean} {@true if the meta key is pressed
          *     on Mac, or the control key is pressed on Windows and Linux}.
          */
-        static modifiers: object
+        static modifiers: any
 
 
         /** 
@@ -2721,20 +2777,20 @@ declare module paper {
         /** 
          * The type of mouse event.
          */
-        type: string
+        type: string | null
 
         /** 
          * The character representation of the key that caused this key event,
          * taking into account the current key-modifiers (e.g. shift, control,
          * caps-lock, etc.)
          */
-        character: string
+        character: string | null
 
         /** 
          * The key that caused this key event, either as a lower-case character or
          * special key descriptor.
          */
-        key: string
+        key: string | null
 
 
         /** 
@@ -2807,37 +2863,37 @@ declare module paper {
          * The value that affects the transformation along the x axis when scaling
          * or rotating, positioned at (0, 0) in the transformation matrix.
          */
-        a: number
+        a: number | null
 
         /** 
          * The value that affects the transformation along the y axis when rotating
          * or skewing, positioned at (1, 0) in the transformation matrix.
          */
-        b: number
+        b: number | null
 
         /** 
          * The value that affects the transformation along the x axis when rotating
          * or skewing, positioned at (0, 1) in the transformation matrix.
          */
-        c: number
+        c: number | null
 
         /** 
          * The value that affects the transformation along the y axis when scaling
          * or rotating, positioned at (1, 1) in the transformation matrix.
          */
-        d: number
+        d: number | null
 
         /** 
          * The distance by which to translate along the x axis, positioned at (2, 0)
          * in the transformation matrix.
          */
-        tx: number
+        tx: number | null
 
         /** 
          * The distance by which to translate along the y axis, positioned at (2, 1)
          * in the transformation matrix.
          */
-        ty: number
+        ty: number | null
 
         /** 
          * The matrix values as an array, in the same sequence as they are passed
@@ -3184,20 +3240,20 @@ declare module paper {
         /** 
          * The type of mouse event.
          */
-        type: string
+        type: string | null
 
         /** 
          * The position of the mouse in project coordinates when the event was
          * fired.
          */
-        point: Point
+        point: Point | null
 
         /** 
          * The item that dispatched the event. It is different from
          * {@link #currentTarget} when the event handler is called during
          * the bubbling phase of the event.
          */
-        target: Item
+        target: Item | null
 
         /** 
          * The current target for the event, as the event traverses the scene graph.
@@ -3205,10 +3261,10 @@ declare module paper {
          * opposed to {@link #target} which identifies the element on
          * which the event occurred.
          */
-        currentTarget: Item
+        currentTarget: Item | null
 
         
-        delta: Point
+        delta: Point | null
 
 
         /** 
@@ -3242,7 +3298,7 @@ declare module paper {
         /** 
          * The version of Paper.js, as a string.
          */
-        version: string
+        readonly version: string
 
         /** 
          * Gives access to paper's configurable settings.
@@ -3258,17 +3314,17 @@ declare module paper {
          * @option [settings.hitTolerance=0] {Number} the default tolerance for hit-
          *     tests, when no value is specified
          */
-        settings: object
+        settings: any
 
         /** 
          * The currently active project.
          */
-        project: Project
+        project: Project | null
 
         /** 
          * The list of all open projects within the current Paper.js context.
          */
-        projects: Project[]
+        projects: Project[] | null
 
         /** 
          * The reference to the active project's view.
@@ -3278,13 +3334,47 @@ declare module paper {
         /** 
          * The reference to the active tool.
          */
-        tool: Tool
+        tool: Tool | null
 
         /** 
          * The list of available tools.
          */
-        tools: Tool[]
+        tools: Tool[] | null
 
+        Color: typeof Color
+        CompoundPath: typeof CompoundPath
+        Curve: typeof Curve
+        CurveLocation: typeof CurveLocation
+        Event: typeof Event
+        Gradient: typeof Gradient
+        GradientStop: typeof GradientStop
+        Group: typeof Group
+        HitResult: typeof HitResult
+        Item: typeof Item
+        Key: typeof Key
+        KeyEvent: typeof KeyEvent
+        Layer: typeof Layer
+        Matrix: typeof Matrix
+        MouseEvent: typeof MouseEvent
+        PaperScript: typeof PaperScript
+        Path: typeof Path
+        PathItem: typeof PathItem
+        Point: typeof Point
+        PointText: typeof PointText
+        Project: typeof Project
+        Raster: typeof Raster
+        Rectangle: typeof Rectangle
+        Segment: typeof Segment
+        Shape: typeof Shape
+        Size: typeof Size
+        Style: typeof Style
+        SymbolDefinition: typeof SymbolDefinition
+        SymbolItem: typeof SymbolItem
+        TextItem: typeof TextItem
+        Tool: typeof Tool
+        ToolEvent: typeof ToolEvent
+        Tween: typeof Tween
+        View: typeof View
 
         /** 
          * Creates a PaperScope object.
@@ -3411,7 +3501,7 @@ declare module paper {
         /** 
          * The segments contained within the path.
          */
-        segments: Segment[]
+        segments: Segment[] | null
 
         /** 
          * The first Segment contained within the path.
@@ -3442,7 +3532,7 @@ declare module paper {
          * Specifies whether the path is closed. If it is closed, Paper.js connects
          * the first and last segments.
          */
-        closed: boolean
+        closed: boolean | null
 
         /** 
          * The approximate length of the path.
@@ -3459,7 +3549,7 @@ declare module paper {
          * Specifies whether the path and all its segments are selected. Cannot be
          * `true` on an empty path.
          */
-        fullySelected: boolean
+        fullySelected: boolean | null
 
 
         /** 
@@ -3502,12 +3592,14 @@ declare module paper {
          * Adds one or more segments to the end of the {@link #segments} array of
          * this path.
          * 
-         * @param segment - the segment or point to be added.
+         * @param segment - the segment or point to be
+         * added.
          * 
-         * @return the added segment. This is not necessarily the same
-         * object, e.g. if the segment to be added already belongs to another path
+         * @return the added segment(s). This is not necessarily
+         * the same object, e.g. if the segment to be added already belongs to
+         * another path.
          */
-        add(segment: Segment | Point): Segment
+        add(...segment: (Segment | Point | Number[])[]): Segment | Segment[]
 
         /** 
          * Inserts one or more segments at a given index in the list of this path's
@@ -3937,12 +4029,12 @@ declare module paper {
          * @see Path#area
          * @see CompoundPath#area
          */
-        clockwise: boolean
+        clockwise: boolean | null
 
         /** 
          * The path's geometry, formatted as SVG style path data.
          */
-        pathData: string
+        pathData: string | null
 
 
         /** 
@@ -4454,12 +4546,12 @@ declare module paper {
         /** 
          * The x coordinate of the point
          */
-        x: number
+        x: number | null
 
         /** 
          * The y coordinate of the point
          */
-        y: number
+        y: number | null
 
         /** 
          * The length of the vector that is represented by this point's coordinates.
@@ -4467,17 +4559,17 @@ declare module paper {
          * = 0`, `y = 0`) to the point's location. Setting the length changes the
          * location but keeps the vector's angle.
          */
-        length: number
+        length: number | null
 
         /** 
          * The vector's angle in degrees, measured from the x-axis to the vector.
          */
-        angle: number
+        angle: number | null
 
         /** 
          * The vector's angle in radians, measured from the x-axis to the vector.
          */
-        angleInRadians: number
+        angleInRadians: number | null
 
         /** 
          * The quadrant of the {@link #angle} of the point.
@@ -4502,7 +4594,7 @@ declare module paper {
          * Paper.js renders selected points on top of your project. This is very
          * useful when debugging.
          */
-        selected: boolean
+        selected: boolean | null
 
 
         /** 
@@ -4891,7 +4983,7 @@ declare module paper {
         /** 
          * The PointText's anchor point
          */
-        point: Point
+        point: Point | null
 
 
         /** 
@@ -4940,7 +5032,7 @@ declare module paper {
          * The currently active path style. All selected items and newly
          * created items will be styled with this style.
          */
-        currentStyle: Style
+        currentStyle: Style | null
 
         /** 
          * The index of the project in the {@link PaperScope#projects} list.
@@ -5266,17 +5358,17 @@ declare module paper {
         /** 
          * The size of the raster in pixels.
          */
-        size: Size
+        size: Size | null
 
         /** 
          * The width of the raster in pixels.
          */
-        width: number
+        width: number | null
 
         /** 
          * The height of the raster in pixels.
          */
-        height: number
+        height: number | null
 
         /** 
          * The loading state of the raster image.
@@ -5296,7 +5388,7 @@ declare module paper {
          * the raster even if the image has already finished loading before, or if
          * we are setting the raster to a canvas.
          */
-        image: HTMLImageElement | HTMLCanvasElement
+        image: HTMLImageElement | HTMLCanvasElement | null
 
         /** 
          * The Canvas object of the raster. If the raster was created from an image,
@@ -5304,12 +5396,12 @@ declare module paper {
          * image into it. Depending on security policies, this might fail, in which
          * case `null` is returned instead.
          */
-        canvas: HTMLCanvasElement
+        canvas: HTMLCanvasElement | null
 
         /** 
          * The Canvas 2D drawing context of the raster.
          */
-        context: CanvasRenderingContext2D
+        context: CanvasRenderingContext2D | null
 
         /** 
          * The source of the raster, which can be set using a DOM Image, a Canvas,
@@ -5320,7 +5412,7 @@ declare module paper {
          * Note that for consistency, a {@link #onLoad} event will be triggered on
          * the raster even if the image has already finished loading before.
          */
-        source: HTMLImageElement | HTMLCanvasElement | string
+        source: HTMLImageElement | HTMLCanvasElement | string | null
 
         /** 
          * The crossOrigin value to be used when loading the image resource, in
@@ -5328,13 +5420,13 @@ declare module paper {
          * {@link #source} property in order to always work (e.g. when the image is
          * cached in the browser).
          */
-        crossOrigin: string
+        crossOrigin: string | null
 
         /** 
          * Specifies if the raster should be smoothed when scaled up or if the
          * pixels should be scaled up by repeating the nearest neighboring pixels.
          */
-        smoothing: boolean
+        smoothing: boolean | null
 
         /** 
          * The event handler function to be called when the underlying image has
@@ -5342,13 +5434,13 @@ declare module paper {
          * the image is already loaded, or when a canvas is used instead of an
          * image.
          */
-        onLoad: Function
+        onLoad: Function | null
 
         /** 
          * The event handler function to be called when there is an error loading
          * the underlying image.
          */
-        onError: Function
+        onError: Function | null
 
 
         /** 
@@ -5482,101 +5574,101 @@ declare module paper {
         /** 
          * The x position of the rectangle.
          */
-        x: number
+        x: number | null
 
         /** 
          * The y position of the rectangle.
          */
-        y: number
+        y: number | null
 
         /** 
          * The width of the rectangle.
          */
-        width: number
+        width: number | null
 
         /** 
          * The height of the rectangle.
          */
-        height: number
+        height: number | null
 
         /** 
          * The top-left point of the rectangle
          */
-        point: Point
+        point: Point | null
 
         /** 
          * The size of the rectangle
          */
-        size: Size
+        size: Size | null
 
         /** 
          * The position of the left hand side of the rectangle. Note that this
          * doesn't move the whole rectangle; the right hand side stays where it was.
          */
-        left: number
+        left: number | null
 
         /** 
          * The top coordinate of the rectangle. Note that this doesn't move the
          * whole rectangle: the bottom won't move.
          */
-        top: number
+        top: number | null
 
         /** 
          * The position of the right hand side of the rectangle. Note that this
          * doesn't move the whole rectangle; the left hand side stays where it was.
          */
-        right: number
+        right: number | null
 
         /** 
          * The bottom coordinate of the rectangle. Note that this doesn't move the
          * whole rectangle: the top won't move.
          */
-        bottom: number
+        bottom: number | null
 
         /** 
          * The center point of the rectangle.
          */
-        center: Point
+        center: Point | null
 
         /** 
          * The top-left point of the rectangle.
          */
-        topLeft: Point
+        topLeft: Point | null
 
         /** 
          * The top-right point of the rectangle.
          */
-        topRight: Point
+        topRight: Point | null
 
         /** 
          * The bottom-left point of the rectangle.
          */
-        bottomLeft: Point
+        bottomLeft: Point | null
 
         /** 
          * The bottom-right point of the rectangle.
          */
-        bottomRight: Point
+        bottomRight: Point | null
 
         /** 
          * The left-center point of the rectangle.
          */
-        leftCenter: Point
+        leftCenter: Point | null
 
         /** 
          * The top-center point of the rectangle.
          */
-        topCenter: Point
+        topCenter: Point | null
 
         /** 
          * The right-center point of the rectangle.
          */
-        rightCenter: Point
+        rightCenter: Point | null
 
         /** 
          * The bottom-center point of the rectangle.
          */
-        bottomCenter: Point
+        bottomCenter: Point | null
 
         /** 
          * The area of the rectangle.
@@ -5589,7 +5681,7 @@ declare module paper {
          * Paper.js draws the bounds of items with selected bounds on top of
          * your project. This is very useful when debugging.
          */
-        selected: boolean
+        selected: boolean | null
 
 
         /** 
@@ -5792,24 +5884,24 @@ declare module paper {
         /** 
          * The anchor point of the segment.
          */
-        point: Point
+        point: Point | null
 
         /** 
          * The handle point relative to the anchor point of the segment that
          * describes the in tangent of the segment.
          */
-        handleIn: Point
+        handleIn: Point | null
 
         /** 
          * The handle point relative to the anchor point of the segment that
          * describes the out tangent of the segment.
          */
-        handleOut: Point
+        handleOut: Point | null
 
         /** 
          * Specifies whether the segment is selected.
          */
-        selected: boolean
+        selected: boolean | null
 
         /** 
          * The index of the segment in the {@link Path#segments} array that the
@@ -6008,18 +6100,18 @@ declare module paper {
         /** 
          * The type of shape of the item as a string.
          */
-        type: string
+        type: string | null
 
         /** 
          * The size of the shape.
          */
-        size: Size
+        size: Size | null
 
         /** 
          * The radius of the shape, as a number if it is a circle, or a size object
          * for ellipses and rounded rectangles.
          */
-        radius: number | Size
+        radius: number | Size | null
 
 
         /** 
@@ -6127,12 +6219,12 @@ declare module paper {
         /** 
          * The width of the size
          */
-        width: number
+        width: number | null
 
         /** 
          * The height of the size
          */
-        height: number
+        height: number | null
 
 
         /** 
@@ -6377,41 +6469,41 @@ declare module paper {
         /** 
          * The color of the stroke.
          */
-        strokeColor: Color
+        strokeColor: Color | null
 
         /** 
          * The width of the stroke.
          */
-        strokeWidth: number
+        strokeWidth: number | null
 
         /** 
          * The shape to be used at the beginning and end of open {@link Path} items,
          * when they have a stroke.
          */
-        strokeCap: string
+        strokeCap: string | null
 
         /** 
          * The shape to be used at the segments and corners of {@link Path} items
          * when they have a stroke.
          */
-        strokeJoin: string
+        strokeJoin: string | null
 
         /** 
          * Specifies whether the stroke is to be drawn taking the current affine
          * transformation into account (the default behavior), or whether it should
          * appear as a non-scaling stroke.
          */
-        strokeScaling: boolean
+        strokeScaling: boolean | null
 
         /** 
          * The dash offset of the stroke.
          */
-        dashOffset: number
+        dashOffset: number | null
 
         /** 
          * Specifies an array containing the dash and gap lengths of the stroke.
          */
-        dashArray: number[]
+        dashArray: number[] | null
 
         /** 
          * The miter limit of the stroke. When two line segments meet at a sharp
@@ -6420,65 +6512,65 @@ declare module paper {
          * the path. The miterLimit imposes a limit on the ratio of the miter length
          * to the {@link #strokeWidth}.
          */
-        miterLimit: number
+        miterLimit: number | null
 
         /** 
          * The fill color.
          */
-        fillColor: Color
+        fillColor: Color | null
 
         /** 
          * The fill-rule with which the shape gets filled. Please note that only
          * modern browsers support fill-rules other than `'nonzero'`.
          */
-        fillRule: string
+        fillRule: string | null
 
         /** 
          * The shadow color.
          */
-        shadowColor: Color
+        shadowColor: Color | null
 
         /** 
          * The shadow's blur radius.
          */
-        shadowBlur: number
+        shadowBlur: number | null
 
         /** 
          * The shadow's offset.
          */
-        shadowOffset: Point
+        shadowOffset: Point | null
 
         /** 
          * The color the item is highlighted with when selected. If the item does
          * not specify its own color, the color defined by its layer is used instead.
          */
-        selectedColor: Color
+        selectedColor: Color | null
 
         /** 
          * The font-family to be used in text content.
          */
-        fontFamily: string
+        fontFamily: string | null
 
         /** 
          * The font-weight to be used in text content.
          */
-        fontWeight: string | number
+        fontWeight: string | number | null
 
         /** 
          * The font size of text content, as a number in pixels, or as a string with
          * optional units `'px'`, `'pt'` and `'em'`.
          */
-        fontSize: number | string
+        fontSize: number | string | null
 
         /** 
          * The text leading of text content.
          */
-        leading: number | string
+        leading: number | string | null
 
         /** 
          * The justification of text paragraphs.
          */
-        justification: string
+        justification: string | null
 
 
         /** 
@@ -6506,7 +6598,7 @@ declare module paper {
         /** 
          * The item used as the symbol's definition.
          */
-        item: Item
+        item: Item | null
 
 
         /** 
@@ -6546,7 +6638,7 @@ declare module paper {
         /** 
          * The symbol definition that the placed symbol refers to.
          */
-        definition: SymbolDefinition
+        definition: SymbolDefinition | null
 
 
         /** 
@@ -6571,33 +6663,33 @@ declare module paper {
         /** 
          * The text contents of the text item.
          */
-        content: string
+        content: string | null
 
         /** 
          * The font-family to be used in text content.
          */
-        fontFamily: string
+        fontFamily: string | null
 
         /** 
          * The font-weight to be used in text content.
          */
-        fontWeight: string | number
+        fontWeight: string | number | null
 
         /** 
          * The font size of text content, as a number in pixels, or as a string with
          * optional units `'px'`, `'pt'` and `'em'`.
          */
-        fontSize: number | string
+        fontSize: number | string | null
 
         /** 
          * The text leading of text content.
          */
-        leading: number | string
+        leading: number | string | null
 
         /** 
          * The justification of text paragraphs.
          */
-        justification: string
+        justification: string | null
 
 
     }
@@ -6618,44 +6710,44 @@ declare module paper {
          * The minimum distance the mouse has to drag before firing the onMouseDrag
          * event, since the last onMouseDrag event.
          */
-        minDistance: number
+        minDistance: number | null
 
         /** 
          * The maximum distance the mouse has to drag before firing the onMouseDrag
          * event, since the last onMouseDrag event.
          */
-        maxDistance: number
+        maxDistance: number | null
 
         
-        fixedDistance: number
+        fixedDistance: number | null
 
         /** 
          * The function to be called when the mouse button is pushed down. The
          * function receives a {@link ToolEvent} object which contains information
          * about the tool event.
          */
-        onMouseDown: Function
+        onMouseDown: Function | null
 
         /** 
          * The function to be called when the mouse position changes while the mouse
          * is being dragged. The function receives a {@link ToolEvent} object which
          * contains information about the tool event.
          */
-        onMouseDrag: Function
+        onMouseDrag: Function | null
 
         /** 
          * The function to be called the mouse moves within the project view. The
          * function receives a {@link ToolEvent} object which contains information
          * about the tool event.
          */
-        onMouseMove: Function
+        onMouseMove: Function | null
 
         /** 
          * The function to be called when the mouse button is released. The function
          * receives a {@link ToolEvent} object which contains information about the
          * tool event.
          */
-        onMouseUp: Function
+        onMouseUp: Function | null
 
         /** 
          * The function to be called when the user presses a key on the keyboard.
@@ -6666,7 +6758,7 @@ declare module paper {
          * from bubbling up. This can be used for example to stop the window from
          * scrolling, when you need the user to interact with arrow keys.
          */
-        onKeyDown: Function
+        onKeyDown: Function | null
 
         /** 
          * The function to be called when the user releases a key on the keyboard.
@@ -6677,7 +6769,7 @@ declare module paper {
          * from bubbling up. This can be used for example to stop the window from
          * scrolling, when you need the user to interact with arrow keys.
          */
-        onKeyUp: Function
+        onKeyUp: Function | null
 
 
         /** 
@@ -6772,25 +6864,25 @@ declare module paper {
         /** 
          * The type of tool event.
          */
-        type: string
+        type: string | null
 
         /** 
          * The position of the mouse in project coordinates when the event was
          * fired.
          */
-        point: Point
+        point: Point | null
 
         /** 
          * The position of the mouse in project coordinates when the previous
          * event was fired.
          */
-        lastPoint: Point
+        lastPoint: Point | null
 
         /** 
          * The position of the mouse in project coordinates when the mouse button
          * was last clicked.
          */
-        downPoint: Point
+        downPoint: Point | null
 
         /** 
          * The point in the middle between {@link #lastPoint} and
@@ -6798,19 +6890,19 @@ declare module paper {
          * artwork based on the moving direction of the mouse, as returned by
          * {@link #delta}.
          */
-        middlePoint: Point
+        middlePoint: Point | null
 
         /** 
          * The difference between the current position and the last position of the
          * mouse when the event was fired. In case of the mouseup event, the
          * difference to the mousedown position is returned.
          */
-        delta: Point
+        delta: Point | null
 
         /** 
          * The number of times the mouse event was fired.
          */
-        count: number
+        count: number | null
 
         /** 
          * The item at the position of the mouse (if any).
@@ -6819,7 +6911,7 @@ declare module paper {
          * {@link CompoundPath} items, the most top level group or compound path
          * that it is contained within is returned.
          */
-        item: Item
+        item: Item | null
 
 
         /** 
@@ -6847,7 +6939,7 @@ declare module paper {
          * object as its sole argument, containing the current progress of the
          * tweening and the factor calculated by the easing function.
          */
-        onUpdate: Function
+        onUpdate: Function | null
 
 
         /** 
@@ -6898,7 +6990,7 @@ declare module paper {
          * Note that this is `true` by default, except for Node.js, where manual
          * updates make more sense.
          */
-        autoUpdate: boolean
+        autoUpdate: boolean | null
 
         /** 
          * The underlying native element.
@@ -6924,7 +7016,7 @@ declare module paper {
          * The size of the view. Changing the view's size will resize it's
          * underlying element.
          */
-        viewSize: Size
+        viewSize: Size | null
 
         /** 
          * The bounds of the currently visible area in project coordinates.
@@ -6939,20 +7031,20 @@ declare module paper {
         /** 
          * The center of the visible area in project coordinates.
          */
-        center: Point
+        center: Point | null
 
         /** 
          * The view's zoom factor by which the project coordinates are magnified.
          * 
          * @see #scaling
          */
-        zoom: number
+        zoom: number | null
 
         /** 
          * The current rotation angle of the view, as described by its
          * {@link #matrix}.
          */
-        rotation: number
+        rotation: number | null
 
         /** 
          * The current scale factor of the view, as described by its
@@ -6960,13 +7052,13 @@ declare module paper {
          * 
          * @see #zoom
          */
-        scaling: Point
+        scaling: Point | null
 
         /** 
          * The view's transformation matrix, defining the view onto the project's
          * contents (position, zoom level, rotation, etc).
          */
-        matrix: Matrix
+        matrix: Matrix | null
 
         /** 
          * Handler function to be called on each frame of an animation.
@@ -6982,12 +7074,12 @@ declare module paper {
          * @option event.delta {Number} the time passed in seconds since the last
          * frame event
          */
-        onFrame: Function
+        onFrame: Function | null
 
         /** 
          * Handler function that is called whenever a view is resized.
          */
-        onResize: Function
+        onResize: Function | null
 
         /** 
          * The function to be called when the mouse button is pushed down on the
@@ -6999,7 +7091,7 @@ declare module paper {
          * 
          * @see Item#onMouseDown
          */
-        onMouseDown: Function
+        onMouseDown: Function | null
 
         /** 
          * The function to be called when the mouse position changes while the mouse
@@ -7011,7 +7103,7 @@ declare module paper {
          * 
          * @see Item#onMouseDrag
          */
-        onMouseDrag: Function
+        onMouseDrag: Function | null
 
         /** 
          * The function to be called when the mouse button is released over the item.
@@ -7020,7 +7112,7 @@ declare module paper {
          * 
          * @see Item#onMouseUp
          */
-        onMouseUp: Function
+        onMouseUp: Function | null
 
         /** 
          * The function to be called when the mouse clicks on the view. The function
@@ -7032,7 +7124,7 @@ declare module paper {
          * 
          * @see Item#onClick
          */
-        onClick: Function
+        onClick: Function | null
 
         /** 
          * The function to be called when the mouse double clicks on the view. The
@@ -7044,7 +7136,7 @@ declare module paper {
          * 
          * @see Item#onDoubleClick
          */
-        onDoubleClick: Function
+        onDoubleClick: Function | null
 
         /** 
          * The function to be called repeatedly while the mouse moves over the
@@ -7056,7 +7148,7 @@ declare module paper {
          * 
          * @see Item#onMouseMove
          */
-        onMouseMove: Function
+        onMouseMove: Function | null
 
         /** 
          * The function to be called when the mouse moves over the view. This
@@ -7069,7 +7161,7 @@ declare module paper {
          * 
          * @see Item#onMouseEnter
          */
-        onMouseEnter: Function
+        onMouseEnter: Function | null
 
         /** 
          * The function to be called when the mouse moves out of the view.
@@ -7081,7 +7173,7 @@ declare module paper {
          * 
          * @see View#onMouseLeave
          */
-        onMouseLeave: Function
+        onMouseLeave: Function | null
 
 
         /** 
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index d893eae2..bbb30aed 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -78,7 +78,7 @@ gulp.task('docs:typescript:build', function() {
         // ...then generate definition from parsed data...
         .pipe(shell('node gulp/typescript/typescript-definition-generator.js'))
         // ...finally test the definition by compiling a typescript file.
-        .pipe(shell('node node_modules/typescript/bin/tsc gulp/typescript/typescript-definition-test.ts'));
+        .pipe(shell('node node_modules/typescript/bin/tsc --project gulp/typescript'));
 });
 // ...finally remove all unneeded temporary files that were used for building.
 gulp.task('docs:typescript:clean:after', function() {
diff --git a/gulp/typescript/tsconfig.json b/gulp/typescript/tsconfig.json
new file mode 100644
index 00000000..7fbc4091
--- /dev/null
+++ b/gulp/typescript/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "strictNullChecks": true
+  },
+  "files"          : [
+    "typescript-definition-test.ts"
+  ]
+}
diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
index eac10f7a..7a8df070 100644
--- a/gulp/typescript/typescript-definition-generator.js
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -9,7 +9,6 @@ const mustache = require('mustache');
 // Retrieve JSDoc data.
 const data = JSON.parse(fs.readFileSync(__dirname + '/typescript-definition-data.json', 'utf8'));
 const classes = data.classes;
-let globals = data.global.properties;
 
 // Format classes.
 classes.forEach(cls => {
@@ -32,7 +31,7 @@ classes.forEach(cls => {
         .filter(filter)
         .map(it => ({
             name: it._name,
-            type: formatType(it.type),
+            type: formatType(it.type, { isProperty: true, isSettableProperty: !it.readOnly }),
             static: formatStatic(it.isStatic),
             readOnly: formatReadOnly(it.readOnly),
             comment: formatComment(it.comment)
@@ -48,7 +47,7 @@ classes.forEach(cls => {
                 name: name,
                 // Constructors don't need return type.
                 type: !it.isConstructor
-                    ? formatType(getMethodReturnType(it), true)
+                    ? formatType(getMethodReturnType(it), { isMethodReturnType: true })
                     : '',
                 static: formatStatic(it.isStatic),
                 // This flag is only used below to filter methods.
@@ -89,21 +88,25 @@ classes.forEach(cls => {
     cls.hasStaticConstructors = cls.staticConstructors.length > 0;
 });
 
-// Format global vriables.
-globals = globals
-// Filter global variables that make no sense in type definition.
-    .filter(it => !/^on/.test(it._name) && it._name !== 'paper')
-    .map(it => ({
-        name: it._name,
-        type: formatType(it.type),
-        comment: formatComment(it.comment)
-    }));
+// PaperScope class needs to be handled slightly differently because it "owns"
+// all the other classes as properties. Eg. we can do `new paperScope.Path()`.
+// So we add a `classesPointers` property that the template will use.
+const paperScopeClass = classes.find(_ => _.className === 'PaperScope');
+paperScopeClass.classesPointers = classes.filter(_ => _.className !== 'PaperScope').map(_ => ({ name: _.className }));
+
+// Since paper.js module is at the same time a PaperScope instance, we need to
+// duplicate PaperScope instance properties and methods in the module scope.
+// For that, we expose a special variable to the template.
+const paperInstance = { ...paperScopeClass };
+// We filter static properties and methods for module scope.
+paperInstance.properties = paperInstance.properties.filter(_ => !_.static);
+paperInstance.methods = paperInstance.methods.filter(_ => !_.static && _.name !== 'constructor');
 
 // Format data trough a mustache template.
 // Prepare data for the template.
 const context = {
+    paperInstance: paperInstance,
     classes: classes,
-    globals: globals,
     version: data.version,
     date: data.date,
     // {{#doc}} blocks are used in template to automatically generate a JSDoc
@@ -130,48 +133,69 @@ function formatStatic(isStatic) {
     return isStatic ? 'static ' : null;
 }
 
-function formatType(type, isMethodReturnType, staticConstructorClass) {
-    return ': ' + parseType(type, isMethodReturnType, staticConstructorClass);
+function formatType(type, options) {
+    return ': ' + parseType(type, options);
 }
 
-function parseType(type, isMethodReturnType, staticConstructorClass) {
+function parseType(type, options) {
     // Always return a type even if input type is empty. In that case, return
     // `void` for method return type and `any` for the rest.
     if (!type) {
-        return isMethodReturnType ? 'void' : 'any';
-    }
-    if (type === '*') {
-        return 'any';
+        return options.isMethodReturnType ? 'void' : 'any';
     }
     // Prefer `any[]` over `Array<any>` to be more consistent with other types.
     if (type === 'Array') {
         return 'any[]';
     }
+    // Handle any type: `*` => `any`
+    type = type.replace('*', 'any');
+    // Check if type is a "rest" type (meaning that an infinite number of
+    // parameter of this type can be passed). In that case, we need to remove
+    // `...` prefix and add `[]` as a suffix:
+    // - `...Type` => `Type[]`
+    // - `...(TypeA|TypeB)` => `(TypeA|TypeB)[]`
+    const isRestType = type.startsWith('...');
+    if (isRestType) {
+        type = type.replace(/^\.\.\./, '');
+    }
     // Handle multiple types possibility by splitting on `|` then re-joining
     // back parsed types.
-    return type.split('|').map(type => {
-        // Handle rest parameter pattern: `...Type` => `Type[]`
-        const matches = type.match(/^\.\.\.(.+)$/);
-        if (matches) {
-            return parseType(matches[1]) + '[]';
-        }
+    type = type.split('|').map(splittedType => {
         // Get type without array suffix `[]` for easier matching.
-        const singleType = type.replace(/(\[\])+$/, '');
+        const singleType = splittedType.replace(/(\[\])+$/, '');
         // Handle eventual type conflict in static constructors block. For
         // example, in `Path.Rectangle(rectangle: Rectangle)` method,
         // `rectangle` parameter type must be mapped to `paper.Rectangle` as it
         // is declared inside a `Path` namespace and would otherwise be wrongly
         // assumed as being the type of `Path.Rectangle` class.
-        if (staticConstructorClass && staticConstructorClass.methods.find(it => it.isStatic && it.isConstructor && formatMethodName(it._name) === singleType)
+        if (options.staticConstructorClass && options.staticConstructorClass.methods.find(it => it.isStatic && it.isConstructor && formatMethodName(it._name) === singleType)
         ) {
-            return 'paper.' + type;
+            return 'paper.' + splittedType;
         }
         // Convert primitive types to their lowercase equivalent to suit
         // typescript best practices.
-        return ['Number', 'String', 'Boolean', 'Object'].indexOf(singleType) >= 0
-            ? type.toLowerCase()
-            : type;
+        if (['Number', 'String', 'Boolean', 'Object'].indexOf(singleType) >= 0) {
+            splittedType = splittedType.toLowerCase();
+        }
+        // Properties `object` type need to be turned into `any` to avoid
+        // errors when reading object properties. Eg. if `property` is of type
+        // `object`, `property.key` access is forbidden.
+        if (options.isProperty && splittedType === 'object') {
+            return 'any';
+        }
+        return splittedType;
     }).join(' | ');
+    if (isRestType) {
+        type += '[]';
+    }
+
+    // We declare settable properties as nullable to be compatible with
+    // TypeScript `strictNullChecks` option (#1664).
+    if (options.isSettableProperty && type !== 'any') {
+        type += ' | null';
+    }
+
+    return type;
 }
 
 function formatMethodName(methodName) {
@@ -195,7 +219,7 @@ function formatParameter(param, staticConstructorClass) {
     if (param.isOptional) {
         content += '?';
     }
-    content += formatType(param.type, false, staticConstructorClass);
+    content += formatType(param.type, { staticConstructorClass });
     return content;
 }
 
@@ -306,11 +330,9 @@ function sortMethods(methodA, methodB) {
         if (methodB.params === 'object: object') {
             return -1;
         }
-    }
-    else if (aIsContructor) {
+    } else if (aIsContructor) {
         return -1;
-    }
-    else if (bIsContructor) {
+    } else if (bIsContructor) {
         return 1;
     }
     return 0;
diff --git a/gulp/typescript/typescript-definition-template.mustache b/gulp/typescript/typescript-definition-template.mustache
index 1065b606..3de46bcc 100644
--- a/gulp/typescript/typescript-definition-template.mustache
+++ b/gulp/typescript/typescript-definition-template.mustache
@@ -15,11 +15,19 @@
  */
 
 declare module paper {
-    {{#globals}}
+    {{#paperInstance}}
+    {{#properties}}
     {{#doc}}4{{/doc}}
     let {{name}}{{type}}
 
-    {{/globals}}
+    {{/properties}}
+
+    {{#methods}}
+    {{#doc}}4{{/doc}}
+    function {{name}}({{params}}){{type}}
+
+    {{/methods}}
+    {{/paperInstance}}
 
     {{#classes}}
 
@@ -30,6 +38,9 @@ declare module paper {
         {{static}}{{readOnly}}{{name}}{{type}}
 
         {{/properties}}
+        {{#classesPointers}}
+        {{name}}: typeof {{name}}
+        {{/classesPointers}}
 
         {{#methods}}
         {{#doc}}8{{/doc}}
diff --git a/gulp/typescript/typescript-definition-test.ts b/gulp/typescript/typescript-definition-test.ts
index ee06d975..0d0cead4 100644
--- a/gulp/typescript/typescript-definition-test.ts
+++ b/gulp/typescript/typescript-definition-test.ts
@@ -13,17 +13,6 @@
 import * as paper from 'paper';
 
 
-//
-// Global
-//
-
-paper.project;
-paper.projects;
-paper.view;
-paper.tool;
-paper.tools;
-
-
 //
 // Utility variables
 //
@@ -368,6 +357,7 @@ item.strokeScaling;
 item.dashArray;
 item.miterLimit;
 item.fillColor;
+item.fillColor && item.fillColor.red;
 item.fillRule;
 item.shadowColor;
 item.shadowBlur;
@@ -538,6 +528,8 @@ raster.source;
 raster.crossOrigin;
 raster.smoothing;
 raster.onLoad;
+raster.onLoad = () => {};
+raster.onLoad = null;
 raster.onError;
 raster.getSubCanvas(rectangle);
 raster.getSubRaster(rectangle);
@@ -662,6 +654,9 @@ path.length;
 path.area;
 path.fullySelected;
 path.add(segment);
+path.add(point);
+path.add([0,0]);
+path.add(segment, point, [0,0]);
 path.insert(0, segment);
 path.addSegments([ segment ]);
 path.insertSegments(0, [ segment ]);
@@ -1048,6 +1043,7 @@ view.responds('');
 
 event.timeStamp;
 event.modifiers;
+event.modifiers.shift;
 event.preventDefault();
 event.stopPropagation();
 event.stop();
@@ -1128,6 +1124,7 @@ keyEvent.toString();
 new paper.PaperScope();
 paperScope.version;
 paperScope.settings;
+paperScope.settings = null;
 paperScope.project;
 paperScope.projects;
 paperScope.view;
@@ -1141,6 +1138,60 @@ paperScope.setup({} as HTMLCanvasElement);
 paperScope.setup(size);
 paperScope.activate();
 paper.PaperScope.get(0);
+new paperScope.Color('');
+new paperScope.CompoundPath('');
+new paperScope.Curve(segment, segment);
+new paperScope.CurveLocation(curve, 0);
+new paperScope.Event();
+new paperScope.Gradient();
+new paperScope.GradientStop();
+new paperScope.Group();
+new paperScope.HitResult();
+new paperScope.Item();
+new paperScope.Key();
+new paperScope.KeyEvent();
+new paperScope.Layer();
+new paperScope.Matrix();
+new paperScope.MouseEvent();
+new paperScope.PaperScript();
+new paperScope.Path();
+new paperScope.PathItem();
+new paperScope.Point(0, 0);
+new paperScope.PointText(point);
+new paperScope.Project(size);
+new paperScope.Raster();
+new paperScope.Rectangle(point, size);
+new paperScope.Segment();
+new paperScope.Shape();
+new paperScope.Size(0,0);
+new paperScope.Style(object);
+new paperScope.SymbolDefinition(item);
+new paperScope.SymbolItem(symbolDefinition);
+new paperScope.TextItem();
+new paperScope.Tool();
+new paperScope.ToolEvent();
+new paperScope.Tween(object, object, object, 0);
+new paperScope.View();
+
+
+//
+// Global PaperScope instance
+//
+
+paper.version;
+paper.settings;
+paper.project;
+paper.projects;
+paper.view;
+paper.tool;
+paper.tools;
+paper.execute('');
+paper.execute('', object);
+paper.install(object);
+paper.setup('');
+paper.setup({} as HTMLCanvasElement);
+paper.setup(size);
+paper.activate();
 
 
 //
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 1d066707..2d4f9670 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -112,6 +112,7 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
      * The version of Paper.js, as a string.
      *
      * @type String
+     * @readonly
      */
     version: /*#=*/__options.version,
 
diff --git a/src/docs/global.js b/src/docs/global.js
index 6345b861..29de23d9 100644
--- a/src/docs/global.js
+++ b/src/docs/global.js
@@ -63,6 +63,7 @@
  *
  * @name view
  * @type View
+ * @readonly
  */
 
 /**
diff --git a/src/path/Path.js b/src/path/Path.js
index 5385e349..aa25ce07 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -483,9 +483,11 @@ var Path = PathItem.extend(/** @lends Path# */{
      * Adds one or more segments to the end of the {@link #segments} array of
      * this path.
      *
-     * @param {Segment|Point} segment the segment or point to be added.
-     * @return {Segment} the added segment. This is not necessarily the same
-     * object, e.g. if the segment to be added already belongs to another path
+     * @param {...(Segment|Point|Number[])} segment the segment or point to be
+     * added.
+     * @return {Segment|Segment[]} the added segment(s). This is not necessarily
+     * the same object, e.g. if the segment to be added already belongs to
+     * another path.
      *
      * @example {@paperscript}
      * // Adding segments to a path using point objects:

From fd4cd90a19b3670cb7c67c598fb9f1c874a8bdab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 13:50:53 +0200
Subject: [PATCH 110/181] Revert built dist files

See https://github.com/paperjs/paper.js/pull/1669#issuecomment-504659166
---
 dist/paper-full.js | 17082 +------------------------------------------
 dist/paper.d.ts    |    27 +-
 2 files changed, 19 insertions(+), 17090 deletions(-)
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index d3acd9a4..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17081 +0,0 @@
-/*!
- * Paper.js v0.12.2-fix/typescript-definition-issues - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Fri Jun 14 15:03:35 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.2-fix/typescript-definition-issues",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		return !!this._contains(
-				this._matrix._inverseTransform(Point.read(arguments)));
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				this._owner[this._setter](this);
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var LinkedColor = Color.extend({
-	initialize: function Color(color, item, setter) {
-		paper.Color.apply(this, [color]);
-		this._item = item;
-		this._setter = setter;
-	},
-
-	_changed: function(){
-		this._item[this._setter](this);
-	}
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner, set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				value;
-			if (key in this._defaults && (!children || !children.length
-					|| _dontMerge || owner instanceof CompoundPath)) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			} else if (children) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-*/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 0f56d7a3..747b7e16 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.2-fix&#x2F;typescript-definition-issues - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.2-develop - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,7 +9,7 @@
  *
  * All rights reserved.
  *
- * Date: Fri Jun 14 15:03:35 2019 +0200
+ * Date: Sat Jun 22 13:46:05 2019 +0200
  *
  * This is an auto-generated type definition.
  */
@@ -270,7 +270,7 @@ declare module paper {
          * parameters that is supported by the various {@link Color}
          * constructors also work for calls of `set()`.
          */
-        set(...value: any[]): Color
+        set(...values: any[]): Color
 
         /** 
          * Converts the color to another type.
@@ -1489,8 +1489,8 @@ declare module paper {
 
         /** 
          * Specifies whether the item defines a clip mask. This can only be set on
-         * paths, compound paths, and text frame objects, and only if the item is
-         * already contained within a clipping group.
+         * paths and compound paths, and only if the item is already contained
+         * within a clipping group.
          */
         clipMask: boolean | null
 
@@ -1531,6 +1531,15 @@ declare module paper {
          */
         handleBounds: Rectangle | null
 
+        /** 
+         * The bounding rectangle of the item without any matrix transformations.
+         * 
+         * Typical use case would be drawing a frame around the object where you
+         * want to draw something of the same size, position, rotation, and scaling,
+         * like a selection frame.
+         */
+        internalBounds: Rectangle | null
+
         /** 
          * The current rotation angle of the item, as described by its
          * {@link #matrix}.
@@ -2958,7 +2967,7 @@ declare module paper {
          * parameters that is supported by the various {@link Matrix} constructors
          * also work for calls of `set()`.
          */
-        set(...value: any[]): Point
+        set(...values: any[]): Point
 
         /** 
          * @return a copy of this transform
@@ -4634,7 +4643,7 @@ declare module paper {
          * that is supported by the various {@link Point} constructors also work
          * for calls of `set()`.
          */
-        set(...value: any[]): Point
+        set(...values: any[]): Point
 
         /** 
          * Checks whether the coordinates of the point are equal to that of the
@@ -5728,7 +5737,7 @@ declare module paper {
          * parameters that is supported by the various {@link Rectangle}
          * constructors also work for calls of `set()`.
          */
-        set(...value: any[]): Rectangle
+        set(...values: any[]): Rectangle
 
         /** 
          * Returns a copy of the rectangle.
@@ -6262,7 +6271,7 @@ declare module paper {
          * that is supported by the various {@link Size} constructors also work
          * for calls of `set()`.
          */
-        set(...value: any[]): Size
+        set(...values: any[]): Size
 
         /** 
          * Checks whether the width and height of the size are equal to those of the

From 68ea63d99eed9f98b0f8afa5697e82f7b60b276d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 14:16:49 +0200
Subject: [PATCH 111/181] Fix JSDoc warning message

---
 gulp/jsdoc        | 2 +-
 src/anim/Tween.js | 4 +++-
 src/view/View.js  | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/gulp/jsdoc b/gulp/jsdoc
index e311a021..6c10a800 160000
--- a/gulp/jsdoc
+++ b/gulp/jsdoc
@@ -1 +1 @@
-Subproject commit e311a021c10ff56b98cd95099485d44a29fab51b
+Subproject commit 6c10a800e2acafdb50b8493c6a67e5cbeec91f10
diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index eb3cc02c..790fee86 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -343,7 +343,9 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
                 return (
                     operator &&
                     operator.match &&
-                    operator.match(/^[+\-*/]=/)
+                    // We're (unnecessarily) escaping '*/' here to not confuse
+                    // the ol' JSDoc parser...
+                    operator.match(/^[+\-\*\/]=/)
                 )
                     ? this._calculate(current, operator[0], value[1])
                     : value;
diff --git a/src/view/View.js b/src/view/View.js
index fc16a67e..13291df6 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -1496,7 +1496,7 @@ new function() { // Injection scope for event handling on the browser
             updateFocus: updateFocus,
 
             /**
-             * Clear all events handling state informations. Made for testing
+             * Clear all events handling state information. Made for testing
              * purpose, to have a way to start with a fresh state before each
              * test.
              * @private

From f89934e331139e8f38fa4902523a1b23e799ef91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 14:40:54 +0200
Subject: [PATCH 112/181] Release version 0.12.3

---
 CHANGELOG.md                |     5 +-
 dist/paper-core.js          | 15331 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17079 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |     4 +-
 gulp/tasks/docs.js          |     7 +-
 gulp/tasks/publish.js       |    14 +-
 package.json                |     2 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 10 files changed, 32426 insertions(+), 22 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7a431291..7df06fcb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## `prebuilt`
+## `0.12.3`
 
 ### Fixed
 
@@ -8,6 +8,7 @@
 - SVG Export: Fix viewport size of exported `Symbol` (#1668).
 - Handle non-invertible matrices in `Item#contains()` (#1651).
 - Improve documentation for `Item#clipMask` (#1673).
+- Improve TypeScript definitions (#1659, #1663, #1664, #1667)
 
 ### Added
 
@@ -35,7 +36,7 @@
 
 ### Added
 
-- Add TypesScript definition, automatically generated from JSDoc comments
+- Add TypeScript definition, automatically generated from JSDoc comments
   (#1612).
 - Support `new Raster(size[, position])` constructor.
 - Expose `Raster#context` accessor.
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..31141047
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15330 @@
+/*!
+ * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat Jun 22 14:16:49 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.3",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..a75c99ff
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17078 @@
+/*!
+ * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat Jun 22 14:16:49 2019 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasObject = value !== undefined;
+		if (hasObject) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				filtered = list.__filtered = Base.create(list[0]);
+				filtered.__unfiltered = list[0];
+			}
+			filtered[name] = undefined;
+		}
+		var l = hasObject ? [value] : list,
+			res = this.read(l, start, options, amount);
+		return res;
+	},
+
+	getNamed: function(list, name) {
+		var arg = list[0];
+		if (list._hasObject === undefined)
+			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
+		if (list._hasObject)
+			return name ? arg[name] : list.__filtered || arg;
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.3",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var point = Point.read(arguments),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(arguments);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var point = Point.read(arguments),
+			tolerance = Base.read(arguments);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var point1 = Point.read(arguments),
+				point2 = Point.read(arguments);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (arguments.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				Base.filter(this, arg0);
+				read = 1;
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(arguments, 'from'),
+				next = Base.peek(arguments),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined
+					|| Base.hasNamed(arguments, 'to')) {
+				var to = Point.readNamed(arguments, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(arguments);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = arguments.__index;
+			var filtered = arguments.__filtered;
+			if (filtered)
+				this.__filtered = filtered;
+		}
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var count = arguments.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, arguments);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, true, Base.pick(recursively, true),
+					_setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var scale = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var shear = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var skew = Point.read(arguments),
+			center = Point.read(arguments, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			return vx === 0 ? vy > 0 ? x - px : px - x
+				 : vy === 0 ? vx < 0 ? y - py : py - y
+				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		return this._hitTest(
+				Point.read(arguments),
+				HitResult.getOptions(arguments));
+	}
+
+	function hitTestAll() {
+		var point = Point.read(arguments),
+			options = HitResult.getOptions(arguments),
+			all = [];
+		this._hitTest(point, Base.set({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyMatrix, _applyRecursively,
+			_setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (_applyMatrix || this._applyMatrix)
+					&& ((!_matrix.isIdentity() || transformMatrix)
+						|| _applyMatrix && _applyRecursively && this._children);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
+				_applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].transform(matrix, true, applyRecursively,
+						setApplyMatrix);
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2)));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = new Shape(Base.getNamed(args), point);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.min(Size.readNamed(arguments, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, arguments);
+		},
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, arguments);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+}, {
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var point = Point.read(arguments),
+			color = Color.read(arguments),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var res = this._definition._item._hitTest(point, options, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return Base.set({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uMax - uMin) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uMax - uMin >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getLoopIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values2 = [],
+			arrays = [],
+			locations,
+			current;
+		for (var i = 0; i < length2; i++)
+			values2[i] = curves2[i].getValues(matrix2);
+		for (var i = 0; i < length1; i++) {
+			var curve1 = curves1[i],
+				values1 = self ? values2[i] : curve1.getValues(matrix1),
+				path1 = curve1.getPath();
+			if (path1 !== current) {
+				current = path1;
+				locations = [];
+				arrays.push(locations);
+			}
+			if (self) {
+				getLoopIntersection(values1, curve1, locations, include);
+			}
+			for (var j = self ? i + 1 : 0; j < length2; j++) {
+				if (_returnFirst && locations.length)
+					return locations;
+				getCurveIntersections(values1, values2[j], curve1, curves2[j],
+						locations, include);
+			}
+		}
+		locations = [];
+		for (var i = 0, l = arrays.length; i < l; i++) {
+			Base.push(locations, arrays[i]);
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getLoopIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				t = end && count > 1 ? roots[count - 1]
+						: count > 0 ? roots[0]
+						: 0.5;
+			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.hasOverlap() || inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
+					if (path1.compare(paths2[i2])) {
+						if (!matched[i2]) {
+							matched[i2] = true;
+							count++;
+						}
+						ok = true;
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: arguments
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? arguments
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		return arguments.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments))
+			: this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		return arguments.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(arguments, 1), index)
+			: this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				t = Base.pick(Base.read(arguments), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(arguments),
+				through,
+				peek = Base.peek(arguments),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(arguments) <= 2) {
+				through = to;
+				to = Point.read(arguments);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(arguments),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(arguments),
+					clockwise = !!Base.read(arguments),
+					large = !!Base.read(arguments),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var through = Point.read(arguments),
+				to = Point.read(arguments),
+				parameter = Base.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var handle1 = Point.read(arguments),
+				handle2 = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var handle = Point.read(arguments),
+				to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(arguments)),
+				clockwise = Base.pick(Base.peek(arguments), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(arguments)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			return createPath([
+				new Segment(Point.readNamed(arguments, 'from')),
+				new Segment(Point.readNamed(arguments, 'to'))
+			], false, arguments);
+		},
+
+		Circle: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				radius = Base.readNamed(arguments, 'radius');
+			return createEllipse(center, new Size(radius), arguments);
+		},
+
+		Rectangle: function() {
+			var rect = Rectangle.readNamed(arguments, 'rectangle'),
+				radius = Size.readNamed(arguments, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, arguments);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var ellipse = Shape._readEllipse(arguments);
+			return createEllipse(ellipse.center, ellipse.radius, arguments);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var from = Point.readNamed(arguments, 'from'),
+				through = Point.readNamed(arguments, 'through'),
+				to = Point.readNamed(arguments, 'to'),
+				props = Base.getNamed(arguments),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				sides = Base.readNamed(arguments, 'sides'),
+				radius = Base.readNamed(arguments, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, arguments);
+		},
+
+		Star: function() {
+			var center = Point.readNamed(arguments, 'center'),
+				points = Base.readNamed(arguments, 'points') * 2,
+				radius1 = Base.readNamed(arguments, 'radius1'),
+				radius2 = Base.readNamed(arguments, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, arguments);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function preparePath(path, resolve) {
+		var res = path.clone(false).reduce({ simplify: true })
+				.transform(null, true, true);
+		return resolve
+				? res.resolveCrossings().reorient(
+					res.getFillRule() === 'nonzero', true)
+				: res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(
+				CurveLocation.expand(_path1.getCrossings(_path2))),
+			paths1 = _path1._children || [_path1],
+			paths2 = _path2 && (_path2._children || [_path2]),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collect(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		if (crossings.length) {
+			collect(paths1);
+			if (paths2)
+				collect(paths2);
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
+						operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2, curves, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getCrossings(_path2),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					point = path1.getInteriorPoint(),
+					containerWinding = 0;
+				for (var j = i - 1; j >= 0; j--) {
+					var path2 = sorted[j];
+					if (path2.contains(point)) {
+						var entry2 = lookup[path2._id];
+						containerWinding = entry2.winding;
+						entry1.winding += containerWinding;
+						entry1.container = entry2.exclude ? entry2.container
+								: path2;
+						break;
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(container ? !container.isClockwise()
+							: clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality = 0;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curves[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curves[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curves, operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve(),
+				length = curve.getLength();
+			chain.push({ segment: segment, curve: curve, length: length });
+			totalLength += length;
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var pathWinding = operand === path1
+										  ? path2._getWinding(pt, dir, true)
+										  : path1._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind = wind || getWinding(pt, curves, dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var value = (rotate ? Base : Point).read(arguments),
+			center = Point.read(arguments, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 747b7e16..4f6635d5 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.2-develop - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,7 +9,7 @@
  *
  * All rights reserved.
  *
- * Date: Sat Jun 22 13:46:05 2019 +0200
+ * Date: Sat Jun 22 14:16:49 2019 +0200
  *
  * This is an auto-generated type definition.
  */
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index bbb30aed..6e20068d 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -50,11 +50,12 @@ Object.keys(docOptions).forEach(function(name) {
 
 // The goal of the typescript task is to automatically generate a type
 // definition for the library.
-gulp.task('docs:typescript', function() {
-    return run(
+gulp.task('docs:typescript', function(callback) {
+    run(
         'docs:typescript:clean:before',
         'docs:typescript:build',
-        'docs:typescript:clean:after'
+        'docs:typescript:clean:after',
+        callback
     );
 });
 // First clean eventually existing type definition...
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index c8efd534..25d37a00 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -38,7 +38,7 @@ gulp.task('publish', function(callback) {
     }
     // publish:website comes before publish:release, so paperjs.zip file is gone
     // before npm publish:
-    return run(
+    run(
         'publish:json',
         'publish:dist',
         'publish:packages',
@@ -83,15 +83,11 @@ gulp.task('publish:release', function() {
         .pipe(shell('npm publish'));
 });
 
-gulp.task('publish:packages', function(callback) {
-    // Publish packages in series instead of in parallel, to see if this fixes
-    // recent issues with `npm publish`:
-    var args = packages.map(function(name) {
+gulp.task('publish:packages',
+    packages.map(function(name) {
         return 'publish:packages:' + name;
     })
-    args.push(callback)
-    return run.call(this, args);
-});
+);
 
 packages.forEach(function(name) {
     gulp.task('publish:packages:' + name, ['publish:version'], function() {
@@ -115,7 +111,7 @@ packages.forEach(function(name) {
 
 gulp.task('publish:website', function(callback) {
     if (fs.lstatSync(sitePath).isDirectory()) {
-        return run(
+        run(
             'publish:website:build',
             'publish:website:push',
             callback
diff --git a/package.json b/package.json
index 9813934f..71b18964 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index f2bef583..0fb6283f 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit f2bef5831a896ac98901a48516fd86393c0c2dd8
+Subproject commit 0fb6283f0955b8ee92fc9ac8838f167ea4a965d2
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index e47ff629..1e276564 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit e47ff6292381cea0ad8cfe7c9ea96db5b02b0279
+Subproject commit 1e276564106e5a29a6e00115c7e703cfc1fc2b09
diff --git a/src/options.js b/src/options.js
index 6741a55a..603cd7ca 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.2';
+var version = '0.12.3';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From b485724f834623cfbb9939db19e4262f15ac22e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 14:43:53 +0200
Subject: [PATCH 113/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15331 +-------------------------------------
 dist/paper-full.js | 17079 +------------------------------------------
 2 files changed, 2 insertions(+), 32408 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 31141047..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15330 +0,0 @@
-/*!
- * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat Jun 22 14:16:49 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.3",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index a75c99ff..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17078 +0,0 @@
-/*!
- * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat Jun 22 14:16:49 2019 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasObject = value !== undefined;
-		if (hasObject) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				filtered = list.__filtered = Base.create(list[0]);
-				filtered.__unfiltered = list[0];
-			}
-			filtered[name] = undefined;
-		}
-		var l = hasObject ? [value] : list,
-			res = this.read(l, start, options, amount);
-		return res;
-	},
-
-	getNamed: function(list, name) {
-		var arg = list[0];
-		if (list._hasObject === undefined)
-			list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-		if (list._hasObject)
-			return name ? arg[name] : list.__filtered || arg;
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.3",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var point = Point.read(arguments),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(arguments);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var point = Point.read(arguments),
-			tolerance = Base.read(arguments);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var point1 = Point.read(arguments),
-				point2 = Point.read(arguments);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (arguments.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				Base.filter(this, arg0);
-				read = 1;
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(arguments, 'from'),
-				next = Base.peek(arguments),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined
-					|| Base.hasNamed(arguments, 'to')) {
-				var to = Point.readNamed(arguments, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(arguments);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = arguments.__index;
-			var filtered = arguments.__filtered;
-			if (filtered)
-				this.__filtered = filtered;
-		}
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var count = arguments.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, arguments);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, true, Base.pick(recursively, true),
-					_setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var scale = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var shear = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var skew = Point.read(arguments),
-			center = Point.read(arguments, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			return vx === 0 ? vy > 0 ? x - px : px - x
-				 : vy === 0 ? vx < 0 ? y - py : py - y
-				 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		return this._hitTest(
-				Point.read(arguments),
-				HitResult.getOptions(arguments));
-	}
-
-	function hitTestAll() {
-		var point = Point.read(arguments),
-			options = HitResult.getOptions(arguments),
-			all = [];
-		this._hitTest(point, Base.set({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyMatrix, _applyRecursively,
-			_setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (_applyMatrix || this._applyMatrix)
-					&& ((!_matrix.isIdentity() || transformMatrix)
-						|| _applyMatrix && _applyRecursively && this._children);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-		if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-				_applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].transform(matrix, true, applyRecursively,
-						setApplyMatrix);
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2)));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = new Shape(Base.getNamed(args), point);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.min(Size.readNamed(arguments, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, arguments);
-		},
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, arguments);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-}, {
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var point = Point.read(arguments),
-			color = Color.read(arguments),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var res = this._definition._item._hitTest(point, options, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return Base.set({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uMax - uMin) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uMax - uMin >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getLoopIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values2 = [],
-			arrays = [],
-			locations,
-			current;
-		for (var i = 0; i < length2; i++)
-			values2[i] = curves2[i].getValues(matrix2);
-		for (var i = 0; i < length1; i++) {
-			var curve1 = curves1[i],
-				values1 = self ? values2[i] : curve1.getValues(matrix1),
-				path1 = curve1.getPath();
-			if (path1 !== current) {
-				current = path1;
-				locations = [];
-				arrays.push(locations);
-			}
-			if (self) {
-				getLoopIntersection(values1, curve1, locations, include);
-			}
-			for (var j = self ? i + 1 : 0; j < length2; j++) {
-				if (_returnFirst && locations.length)
-					return locations;
-				getCurveIntersections(values1, values2[j], curve1, curves2[j],
-						locations, include);
-			}
-		}
-		locations = [];
-		for (var i = 0, l = arrays.length; i < l; i++) {
-			Base.push(locations, arrays[i]);
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getLoopIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				t = end && count > 1 ? roots[count - 1]
-						: count > 0 ? roots[0]
-						: 0.5;
-			offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.hasOverlap() || inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-					if (path1.compare(paths2[i2])) {
-						if (!matched[i2]) {
-							matched[i2] = true;
-							count++;
-						}
-						ok = true;
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: arguments
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? arguments
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		return arguments.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments))
-			: this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		return arguments.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(arguments, 1), index)
-			: this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				t = Base.pick(Base.read(arguments), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(arguments),
-				through,
-				peek = Base.peek(arguments),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(arguments) <= 2) {
-				through = to;
-				to = Point.read(arguments);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(arguments),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(arguments),
-					clockwise = !!Base.read(arguments),
-					large = !!Base.read(arguments),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var through = Point.read(arguments),
-				to = Point.read(arguments),
-				parameter = Base.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var handle1 = Point.read(arguments),
-				handle2 = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var handle = Point.read(arguments),
-				to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(arguments)),
-				clockwise = Base.pick(Base.peek(arguments), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(arguments)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			return createPath([
-				new Segment(Point.readNamed(arguments, 'from')),
-				new Segment(Point.readNamed(arguments, 'to'))
-			], false, arguments);
-		},
-
-		Circle: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				radius = Base.readNamed(arguments, 'radius');
-			return createEllipse(center, new Size(radius), arguments);
-		},
-
-		Rectangle: function() {
-			var rect = Rectangle.readNamed(arguments, 'rectangle'),
-				radius = Size.readNamed(arguments, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, arguments);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var ellipse = Shape._readEllipse(arguments);
-			return createEllipse(ellipse.center, ellipse.radius, arguments);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var from = Point.readNamed(arguments, 'from'),
-				through = Point.readNamed(arguments, 'through'),
-				to = Point.readNamed(arguments, 'to'),
-				props = Base.getNamed(arguments),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				sides = Base.readNamed(arguments, 'sides'),
-				radius = Base.readNamed(arguments, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, arguments);
-		},
-
-		Star: function() {
-			var center = Point.readNamed(arguments, 'center'),
-				points = Base.readNamed(arguments, 'points') * 2,
-				radius1 = Base.readNamed(arguments, 'radius1'),
-				radius2 = Base.readNamed(arguments, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, arguments);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function preparePath(path, resolve) {
-		var res = path.clone(false).reduce({ simplify: true })
-				.transform(null, true, true);
-		return resolve
-				? res.resolveCrossings().reorient(
-					res.getFillRule() === 'nonzero', true)
-				: res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(
-				CurveLocation.expand(_path1.getCrossings(_path2))),
-			paths1 = _path1._children || [_path1],
-			paths2 = _path2 && (_path2._children || [_path2]),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collect(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		if (crossings.length) {
-			collect(paths1);
-			if (paths2)
-				collect(paths2);
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-						operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2, curves, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getCrossings(_path2),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					point = path1.getInteriorPoint(),
-					containerWinding = 0;
-				for (var j = i - 1; j >= 0; j--) {
-					var path2 = sorted[j];
-					if (path2.contains(point)) {
-						var entry2 = lookup[path2._id];
-						containerWinding = entry2.winding;
-						entry1.winding += containerWinding;
-						entry1.container = entry2.exclude ? entry2.container
-								: path2;
-						break;
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(container ? !container.isClockwise()
-							: clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality = 0;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curves[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curves[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curves, operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve(),
-				length = curve.getLength();
-			chain.push({ segment: segment, curve: curve, length: length });
-			totalLength += length;
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var pathWinding = operand === path1
-										  ? path2._getWinding(pt, dir, true)
-										  : path1._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind = wind || getWinding(pt, curves, dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var value = (rotate ? Base : Point).read(arguments),
-			center = Point.read(arguments, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From 4172eafba0799f23cb0ceee6de5d839d83531e8c Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Sat, 22 Jun 2019 15:17:35 +0200
Subject: [PATCH 114/181] Add/unit test for color change propagation (#1675)

Relates to #1672
---
 test/tests/Style.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/test/tests/Style.js b/test/tests/Style.js
index f930592b..8e22e56c 100644
--- a/test/tests/Style.js
+++ b/test/tests/Style.js
@@ -192,3 +192,30 @@ test('setting Group#fillColor and #strokeColor 2', function() {
     // The second path still has its strokeColor set to red:
     equals(secondPath.strokeColor, new Color('red'), 'secondPath.strokeColor');
 });
+
+test('Color change propagation (#1672)', function(assert) {
+    // We use this trick to take a snapshot of the current canvas content
+    // without any kind of side effect that `item.rasterize()` or other
+    // techniques would have.
+    function getDataURL() {
+        view.update();
+        return view.context.canvas.toDataURL();
+    }
+
+    var item = new Path.Circle({
+        center: view.center,
+        radius: 70,
+        fillColor: 'red'
+    });
+    var imageDataBefore = getDataURL();
+
+    // Change style property and check that change was detected.
+    item.fillColor.hue += 100;
+    var imageDataAfter = getDataURL();
+
+    // We are limited to check that both snapshots are different.
+    equals(
+        imageDataBefore !== imageDataAfter, true,
+        'Canvas content should change after a change of item.fillColor.'
+    );
+});

From a5a13f541a51ec2a033823e0d37788177c6004e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 15:18:18 +0200
Subject: [PATCH 115/181] Update JSDoc to fix regression in link rendering

---
 gulp/jsdoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gulp/jsdoc b/gulp/jsdoc
index 6c10a800..4e89b701 160000
--- a/gulp/jsdoc
+++ b/gulp/jsdoc
@@ -1 +1 @@
-Subproject commit 6c10a800e2acafdb50b8493c6a67e5cbeec91f10
+Subproject commit 4e89b70137883c0ab6fc24986cc6452362568ddb

From f66c73e53440662e6ee1f2bed925516f84f83f2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 15:27:25 +0200
Subject: [PATCH 116/181] Fix regression in curve-intersections code

Closes #1638
---
 src/path/Curve.js                |  8 ++++++--
 test/tests/Path_Intersections.js | 15 +++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/path/Curve.js b/src/path/Curve.js
index 26798499..241df0e5 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -1822,9 +1822,10 @@ new function() { // Scope for bezier intersection using fat-line clipping
         } else {
             // Apply the result of the clipping to curve 1:
             v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+            var uDiff = uMax - uMin;
             if (tMaxClip - tMinClip > 0.8) {
                 // Subdivide the curve which has converged the least.
-                if (tMaxNew - tMinNew > uMax - uMin) {
+                if (tMaxNew - tMinNew > uDiff) {
                     var parts = Curve.subdivide(v1, 0.5),
                         t = (tMinNew + tMaxNew) / 2;
                     calls = addCurveIntersections(
@@ -1844,7 +1845,10 @@ new function() { // Scope for bezier intersection using fat-line clipping
                             recursion, calls, u, uMax, tMinNew, tMaxNew);
                 }
             } else { // Iterate
-                if (uMax - uMin >= fatLineEpsilon) {
+                // For some unclear reason we need to check against uDiff === 0
+                // here, to prevent a regression from happening, see #1638.
+                // Maybe @iconexperience could shed some light on this.
+                if (uDiff === 0 || uDiff >= fatLineEpsilon) {
                     calls = addCurveIntersections(
                             v2, v1, c2, c1, locations, include, !flip,
                             recursion, calls, uMin, uMax, tMinNew, tMaxNew);
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 6e69ec65..53b25e36 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -343,3 +343,18 @@ test('#1284', function() {
     var path2 = createPath(curve2);
     testIntersections(path1.getIntersections(path2), expected);
 });
+
+test('#1638', function() {
+    var circle1 = new Path.Circle({
+        center: [100, 100],
+        radius: 100
+    });
+    var circle2 = new Path.Circle({
+        center: [150, 150],
+        radius: 100
+    });
+    testIntersections(circle1.getIntersections(circle2), [
+        { point: { x: 191.16238, y: 58.83762 }, index: 1, time: 0.73431, crossing: true },
+        { point: { x: 58.83762, y: 191.16238 }, index: 3, time: 0.26569, crossing: true }
+    ]);
+})

From 3ff5560c0c16a1ecd581ab558d6682becd6ddd75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 17:31:36 +0200
Subject: [PATCH 117/181] Improve CurveLocation.isCrossing()

Better handles edge cases in offsetting tests
---
 src/path/CurveLocation.js | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 19b31dc9..994840f7 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -450,18 +450,19 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
             var v = curve.getValues(),
                 roots = Curve.classify(v).roots || Curve.getPeaks(v),
                 count = roots.length,
-                t = end && count > 1 ? roots[count - 1]
-                        : count > 0 ? roots[0]
-                        : 0.5;
-            // Then use half of the offset, for extra measure.
-            offsets.push(Curve.getLength(v, end ? t : 0, end ? 1 : t) / 2);
+                offset = Curve.getLength(v,
+                    end && count ? roots[count - 1] : 0,
+                    !end && count ? roots[0] : 1);
+            // When no root was found, the full length was calculated. Use a
+            // fraction of it. By trial & error, 64 was determined to work well.
+            offsets.push(count ? offset : offset / 64);
         }
 
         function isInRange(angle, min, max) {
             return min < max
-                    ? angle > min && angle < max
+                    ? angle > min && angle <= max
                     // min > max: the range wraps around -180 / 180 degrees
-                    : angle > min || angle < max;
+                    : angle > min || angle <= max;
         }
 
         if (!t1Inside) {

From ef8ba35911114dd8d4136c64ed7bd1a0f0cb16c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 18:21:47 +0200
Subject: [PATCH 118/181] Implement unit tests for
 3ff5560c0c16a1ecd581ab558d6682becd6ddd75

Closes #1419, closes #1263
---
 src/path/CurveLocation.js        |  2 +-
 test/helpers.js                  |  4 ++--
 test/tests/Path_Boolean.js       | 13 +++++++++++++
 test/tests/Path_Intersections.js | 13 +++++++++++++
 4 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 994840f7..7ebd41c8 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -492,7 +492,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
         // Count how many times curve2 angles appear between the curve1 angles.
         // If each pair of angles split the other two, then the edges cross.
         // Use t1Inside to decide which angle pair to check against.
-        // If t1 is inside the curve, check against a3 & a4, othrwise a1 & a2.
+        // If t1 is inside the curve, check against a3 & a4, otherwise a1 & a2.
         return !!(t1Inside
                 ? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
                   (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
diff --git a/test/helpers.js b/test/helpers.js
index 28e8be91..fcb0b356 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -227,8 +227,8 @@ var compareImageData = function(imageData1, imageData2, tolerance, diffDetail) {
         var entry = document.getElementById('qunit-test-output-' + id)
             .querySelector('li:nth-child(' + (index) + ')'),
             bounds = result.diffBounds;
-        entry.querySelector('.test-expected td').appendChild(image(imageData1));
-        entry.querySelector('.test-actual td').appendChild(image(imageData2));
+        entry.querySelector('.test-expected td').appendChild(image(imageData2));
+        entry.querySelector('.test-actual td').appendChild(image(imageData1));
         entry.querySelector('.test-diff td').innerHTML = '<pre>' + detail
             + '</pre><br>'
             + '<img src="' + result.getImageDataUrl() + '">';
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index c965ee89..764fdcae 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -1202,3 +1202,16 @@ test('#1513', function () {
     var result = 'M100,100h200v100c0,-55.22847 -44.77153,-100 -100,-100c-55.22847,0 -100,44.77153 -100,100z';
     compareBoolean(path1.subtract(path2), result);
 });
+
+test('#1419', function() {
+    var circle1 = Path.Circle({
+        center: [0, 0],
+        radius: 50
+    });
+    var circle2 = Path.Circle({
+        center: circle1.position.subtract(25),
+        radius: 50
+    });
+    var result = 'M-50,0c0,-27.61424 22.38576,-50 50,-50c7.33673,0 14.30439,1.5802 20.58119,4.41881c-7.84546,-17.34804 -25.30368,-29.41881 -45.58119,-29.41881c-27.61424,0 -50,22.38576 -50,50c0,20.27751 12.07077,37.73573 29.41881,45.58119c-2.83861,-6.2768 -4.41881,-13.24446 -4.41881,-20.58119zM50,0c0,27.61424 -22.38576,50 -50,50c-20.27751,0 -37.73573,-12.07077 -45.58119,-29.41881c6.2768,2.83861 13.24446,4.41881 20.58119,4.41881c27.61424,0 50,-22.38576 50,-50c0,-7.33673 -1.5802,-14.30439 -4.41881,-20.58119c17.34804,7.84546 29.41881,25.30368 29.41881,45.58119z';
+    compareBoolean(circle1.exclude(circle2), result);
+})
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 53b25e36..4c1450df 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -358,3 +358,16 @@ test('#1638', function() {
         { point: { x: 58.83762, y: 191.16238 }, index: 3, time: 0.26569, crossing: true }
     ]);
 })
+
+test('#1263', function() {
+    var path = new Path({
+        segments: [
+            [[479,495], [0,0], [-10,4]],
+            [[437,479], [5,12], [-22,-51]],
+            [[479,495], [33,-15]]
+        ]
+    });
+    testIntersections(path.getIntersections(), [
+        { point: { x: 479, y: 495 }, index: 0, time: 0, crossing: false }
+    ]);
+})

From e779d24a6dc571ed4c76987853d60444479ab21b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 18:42:19 +0200
Subject: [PATCH 119/181] Implement higher precision in getSignedDistance()

Also add unit test for overlap edge case.
Closes #1262
---
 src/basic/Line.js                | 10 +++++++---
 test/tests/Path_Intersections.js | 13 +++++++++++--
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/basic/Line.js b/src/basic/Line.js
index 84893fd8..98043e91 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -196,9 +196,13 @@ var Line = Base.extend(/** @lends Line# */{
                 vy -= py;
             }
             // Based on the error analysis by @iconexperience outlined in #799
-            return vx === 0 ? vy > 0 ? x - px : px - x
-                 : vy === 0 ? vx < 0 ? y - py : py - y
-                 : ((x-px) * vy - (y-py) * vx) / Math.sqrt(vx * vx + vy * vy);
+              return  vx === 0 ? (vy > 0 ? x - px : px - x)
+                    : vy === 0 ? (vx < 0 ? y - py : py - y)
+                    : ((x - px) * vy - (y - py) * vx) / (
+                        vy > vx
+                            ? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+                            : vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+                    );
         },
 
         getDistance: function(px, py, vx, vy, x, y, asVector) {
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 4c1450df..370bbf8d 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -357,7 +357,7 @@ test('#1638', function() {
         { point: { x: 191.16238, y: 58.83762 }, index: 1, time: 0.73431, crossing: true },
         { point: { x: 58.83762, y: 191.16238 }, index: 3, time: 0.26569, crossing: true }
     ]);
-})
+});
 
 test('#1263', function() {
     var path = new Path({
@@ -370,4 +370,13 @@ test('#1263', function() {
     testIntersections(path.getIntersections(), [
         { point: { x: 479, y: 495 }, index: 0, time: 0, crossing: false }
     ]);
-})
+});
+
+test('#1262', function() {
+    var c1 = new Curve([561.5500544, 629.1148694240001, 564.581554256, 629.1148694240001, 567.0556160000001, 631.588931168, 567.0556160000001, 634.620431024]);
+    var c2 = new Curve([561.5500544, 629.1148694240001, 564.581554256, 629.1148694240001, 567.0556160000001, 631.592372144, 567.0556160000001, 634.620431024]);
+    testIntersections(c1.getIntersections(c2), [
+        { point: { x: 561.55005, y: 629.11487 }, time: 0 },
+        { point: { x: 567.05562, y: 634.62043 }, time: 1 }
+    ]);
+});

From 978cd94a9ea9b1dab1bcafc3bd68b86f4225d53e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 18:48:16 +0200
Subject: [PATCH 120/181] Boolean: Add check for paths with only one segment

Closes #1351
---
 src/path/PathItem.Boolean.js | 12 ++++++++----
 test/tests/Path_Boolean.js   |  9 ++++++++-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 018555aa..3534a224 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -715,10 +715,14 @@ PathItem.inject(new function() {
             totalLength = 0,
             winding;
         do {
-            var curve = segment.getCurve(),
-                length = curve.getLength();
-            chain.push({ segment: segment, curve: curve, length: length });
-            totalLength += length;
+            var curve = segment.getCurve();
+            // We can encounter paths with only one segment, which would not
+            // have a curve.
+            if (curve) {
+                var length = curve.getLength();
+                chain.push({ segment: segment, curve: curve, length: length });
+                totalLength += length;
+            }
             segment = segment.getNext();
         } while (segment && !segment._intersection && segment !== start);
         // Determine winding at three points in the chain. If a winding with
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index 764fdcae..0d448243 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -1214,4 +1214,11 @@ test('#1419', function() {
     });
     var result = 'M-50,0c0,-27.61424 22.38576,-50 50,-50c7.33673,0 14.30439,1.5802 20.58119,4.41881c-7.84546,-17.34804 -25.30368,-29.41881 -45.58119,-29.41881c-27.61424,0 -50,22.38576 -50,50c0,20.27751 12.07077,37.73573 29.41881,45.58119c-2.83861,-6.2768 -4.41881,-13.24446 -4.41881,-20.58119zM50,0c0,27.61424 -22.38576,50 -50,50c-20.27751,0 -37.73573,-12.07077 -45.58119,-29.41881c6.2768,2.83861 13.24446,4.41881 20.58119,4.41881c27.61424,0 50,-22.38576 50,-50c0,-7.33673 -1.5802,-14.30439 -4.41881,-20.58119c17.34804,7.84546 29.41881,25.30368 29.41881,45.58119z';
     compareBoolean(circle1.exclude(circle2), result);
-})
+});
+
+test('#1351', function() {
+    var path1 = new CompoundPath(new Path([10, 10], [100, 100]), new Path([150, 25]));
+    var path2 = new Path([20, 80], [80, 20]);
+    var result = 'M10,10l40,40l50,50';
+    compareBoolean(path1.unite(path2), result);
+});

From 15e00e0b99b5f59215028826a39321248f433d7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 22 Jun 2019 23:05:50 +0200
Subject: [PATCH 121/181] Introduce Numerical.isMachineZero()

Used in places requiring smaller epsilons for zero comparisons
---
 src/basic/Line.js            | 4 ++--
 src/path/Curve.js            | 6 +++---
 src/path/CurveLocation.js    | 2 +-
 src/path/PathFitter.js       | 2 +-
 src/path/PathItem.Boolean.js | 2 +-
 src/util/Numerical.js        | 4 ++++
 6 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/basic/Line.js b/src/basic/Line.js
index 98043e91..a77fa087 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -141,7 +141,7 @@ var Line = Base.extend(/** @lends Line# */{
             }
             var cross = v1x * v2y - v1y * v2x;
             // Avoid divisions by 0, and errors when getting too close to 0
-            if (!Numerical.isZero(cross)) {
+            if (!Numerical.isMachineZero(cross)) {
                 var dx = p1x - p2x,
                     dy = p1y - p2y,
                     u1 = (v2x * dy - v2y * dx) / cross,
@@ -175,7 +175,7 @@ var Line = Base.extend(/** @lends Line# */{
                 v2y = y - py,
                 // ccw = v2.cross(v1);
                 ccw = v2x * vy - v2y * vx;
-            if (!isInfinite && Numerical.isZero(ccw)) {
+            if (!isInfinite && Numerical.isMachineZero(ccw)) {
                 // If the point is on the infinite line, check if it's on the
                 // finite line too: Project v2 onto v1 and determine ccw based
                 // on which side of the finite line the point lies. Calculate
diff --git a/src/path/Curve.js b/src/path/Curve.js
index 241df0e5..ac23371b 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2091,7 +2091,7 @@ new function() { // Scope for bezier intersection using fat-line clipping
         return locations;
     }
 
-    function getLoopIntersection(v1, c1, locations, include) {
+    function getSelfIntersection(v1, c1, locations, include) {
         var info = Curve.classify(v1);
         if (info.type === 'loop') {
             var roots = info.roots;
@@ -2131,7 +2131,7 @@ new function() { // Scope for bezier intersection using fat-line clipping
             }
             if (self) {
                 // First check for self-intersections within the same curve.
-                getLoopIntersection(values1, curve1, locations, include);
+                getSelfIntersection(values1, curve1, locations, include);
             }
             // Check for intersections with other curves.
             // For self-intersection, we can start at i + 1 instead of 0.
@@ -2314,7 +2314,7 @@ new function() { // Scope for bezier intersection using fat-line clipping
             var v1 = this.getValues(),
                 v2 = curve && curve !== this && curve.getValues();
             return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-                      : getLoopIntersection(v1, this, []);
+                      : getSelfIntersection(v1, this, []);
         },
 
         statics: /** @lends Curve */{
diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 7ebd41c8..6adfda86 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -59,7 +59,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
 
     _setCurve: function(curve) {
         var path = curve._path;
-        // We only store the path to verify versions for cachd values.
+        // We only store the path to verify versions for cached values.
         // To ensure we use the right path (e.g. after splitting), we shall
         // always access the path on the result of getCurve().
         this._path = path;
diff --git a/src/path/PathFitter.js b/src/path/PathFitter.js
index 27361e69..b5e6e14c 100644
--- a/src/path/PathFitter.js
+++ b/src/path/PathFitter.js
@@ -231,7 +231,7 @@ var PathFitter = Base.extend({
             diff = pt.subtract(point),
             df = pt1.dot(pt1) + diff.dot(pt2);
         // u = u - f(u) / f'(u)
-        return Numerical.isZero(df) ? u : u - diff.dot(pt1) / df;
+        return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
     },
 
     // Evaluate a bezier curve at a particular parameter value
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 3534a224..f31a35b0 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -1172,7 +1172,7 @@ PathItem.inject(new function() {
                 return inter && inter._overlap && inter._path === path;
             }
 
-            // First collect all overlaps and crossings while taking not of the
+            // First collect all overlaps and crossings while taking note of the
             // existence of both.
             var hasOverlaps = false,
                 hasCrossings = false,
diff --git a/src/util/Numerical.js b/src/util/Numerical.js
index 54d4c5db..5510ef0d 100644
--- a/src/util/Numerical.js
+++ b/src/util/Numerical.js
@@ -168,6 +168,10 @@ var Numerical = new function() {
             return val >= -EPSILON && val <= EPSILON;
         },
 
+        isMachineZero: function(val) {
+            return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+        },
+
         /**
          * Returns a number whose value is clamped by the given range.
          *

From 14ce1dc0117d9038dca7f7fd3fc3bd13e8ebd7f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 03:24:13 +0200
Subject: [PATCH 122/181] Boolean: Correctly handle open filled paths

Closes #1647
---
 src/path/CurveLocation.js    |  4 ++--
 src/path/PathItem.Boolean.js | 35 ++++++++++++++++++++++++++++-------
 test/tests/Path_Boolean.js   |  8 ++++++++
 3 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 6adfda86..7d6dd9df 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -424,9 +424,9 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
         //   both values point to the same curve, and the curve-time is to be
         //   handled accordingly further down.
         var c2 = this.getCurve(),
-            c1 = t1 < tMin ? c2.getPrevious() : c2,
+            c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
             c4 = inter.getCurve(),
-            c3 = t2 < tMin ? c4.getPrevious() : c4;
+            c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
         // If t1 / t2 are at the end, then step to the next curve.
         if (t1 > tMax)
             c2 = c2.getNext();
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index f31a35b0..30c38d36 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -46,6 +46,10 @@ PathItem.inject(new function() {
             exclude:   { '1': true, '-1': true }
         };
 
+    function getPaths(path) {
+        return path._children || [path];
+    }
+
     /*
      * Creates a clone of the path that we can modify freely, with its matrix
      * applied to its geometry. Calls #reduce() to simplify compound paths and
@@ -53,12 +57,29 @@ PathItem.inject(new function() {
      * make sure all paths have correct winding direction.
      */
     function preparePath(path, resolve) {
-        var res = path.clone(false).reduce({ simplify: true })
-                .transform(null, true, true);
+        var res = path
+            .clone(false)
+            .reduce({ simplify: true })
+            .transform(null, true, true);
+        // For correct results, close open filled paths with straight lines:
+        if (resolve && res.hasFill()) {
+            var paths = getPaths(res);
+            for (var i = 0, l = paths.length; i < l; i++) {
+                var path = paths[i];
+                if (!path._closed) {
+                    // Close with epsilon tolerance, to avoid tiny straight
+                    // that would cause issues with intersection detection.
+                    path.closePath(/*#=*/Numerical.EPSILON);
+                    path.getFirstSegment().setHandleIn(0, 0);
+                    path.getLastSegment().setHandleOut(0, 0);
+                }
+            }
+        }
         return resolve
-                ? res.resolveCrossings().reorient(
-                    res.getFillRule() === 'nonzero', true)
-                : res;
+            ? res
+                .resolveCrossings()
+                .reorient(res.getFillRule() === 'nonzero', true)
+            : res;
     }
 
     function createResult(paths, simplify, path1, path2, options) {
@@ -103,8 +124,8 @@ PathItem.inject(new function() {
         // intersection, path2 is null and getIntersections() handles it.
         var crossings = divideLocations(
                 CurveLocation.expand(_path1.getCrossings(_path2))),
-            paths1 = _path1._children || [_path1],
-            paths2 = _path2 && (_path2._children || [_path2]),
+            paths1 = getPaths(_path1),
+            paths2 = _path2 && getPaths(_path2),
             segments = [],
             curves = [],
             paths;
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index 0d448243..bab08843 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -1222,3 +1222,11 @@ test('#1351', function() {
     var result = 'M10,10l40,40l50,50';
     compareBoolean(path1.unite(path2), result);
 });
+
+test('#1647', function() {
+    var path1 = PathItem.create("M0,0h60v60h-60z");
+    var path2 = PathItem.create("M60,47c-0.89493,-0.00177 -1.72254,0.47497 -2.17,1.25l-12.12,21c-0.44703,0.77427 -0.44656,1.72831 0.00123,2.50214c0.44779,0.77383 1.27472,1.24963 2.16877,1.24786h24.24c0.89405,0.00177 1.72098,-0.47403 2.16877,-1.24786c0.44779,-0.77383 0.44826,-1.72787 0.00123,-2.50214l-12.12,-21c-0.44746,-0.77503 -1.27507,-1.25177 -2.17,-1.25M64.33,47l12.12,21c0.89315,1.54699 0.89316,3.45295 0.00003,4.99995c-0.89313,1.547 -2.54373,2.50001 -4.33003,2.50005h-24.24c-1.78631,-0.00005 -3.4369,-0.95306 -4.33003,-2.50005c-0.89313,-1.547 -0.89312,-3.45296 0.00003,-4.99995l12.12,-21c0.88236,-1.55771 2.53981,-2.51466 4.33,-2.5c1.79019,-0.01466 3.44764,0.94229 4.33,2.5");
+    path1.fillColor = path2.fillColor = 'black';
+    var result = 'M57.83,48.25l-6.78143,11.75l-2.88143,0l7.50286,-13c0.88236,-1.55771 2.53981,-2.51466 4.33,-2.5v2.5c-0.89493,-0.00177 -1.72254,0.47497 -2.17,1.25z';
+    compareBoolean(path1.intersect(path2), result);
+});

From 192437dbe26159a9b7412e258003c781ad469d5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 04:19:20 +0200
Subject: [PATCH 123/181] Boolean: Avoid winding edge cases

Stay clear from testing winding on actual segments.
Closes #1619
---
 src/path/PathItem.Boolean.js |  3 ++-
 test/tests/Path_Boolean.js   | 22 ++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 30c38d36..e4f37459 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -751,7 +751,8 @@ PathItem.inject(new function() {
         // the best quality.
         var offsets = [0.5, 0.25, 0.75],
             winding = { winding: 0, quality: -1 },
-            tMin = /*#=*/Numerical.CURVETIME_EPSILON,
+            // Don't go too close to segments, to avoid special winding cases:
+            tMin = 1e-3,
             tMax = 1 - tMin;
         for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
             var length = totalLength * offsets[i];
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index bab08843..292bede7 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -1230,3 +1230,25 @@ test('#1647', function() {
     var result = 'M57.83,48.25l-6.78143,11.75l-2.88143,0l7.50286,-13c0.88236,-1.55771 2.53981,-2.51466 4.33,-2.5v2.5c-0.89493,-0.00177 -1.72254,0.47497 -2.17,1.25z';
     compareBoolean(path1.intersect(path2), result);
 });
+
+test('#1619', function() {
+    var path1 = new Path.Rectangle({
+        from: [200, 600],
+        to: [400, 300]
+    });
+
+    var path2 = new CompoundPath({
+        children: [
+            new Path({
+                segments: [[420,320],[380,580],[220,580],[220,320]],
+                closed: true
+            }),
+            new Path({
+                segments: [[313.36486,413.71682],[243.351,483.70296],[313.33714,553.71682],[383.351,483.73068]],
+                closed: true
+            })
+        ]
+    });
+    var result = 'M380,580h-160v-260l180,0v130zM313.36486,413.71682l-70.01386,69.98614l69.98614,70.01386l70.01386,-69.98614z';
+    compareBoolean(path1.intersect(path2), result);
+});

From 2ef8175cb8c1d889371640670b57abc0406f0bb0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 04:47:34 +0200
Subject: [PATCH 124/181] Boolean: No need to actually check for fill

---
 src/path/PathItem.Boolean.js | 15 +++++++--------
 test/tests/Path_Boolean.js   |  7 +++----
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index e4f37459..02caa192 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -61,12 +61,12 @@ PathItem.inject(new function() {
             .clone(false)
             .reduce({ simplify: true })
             .transform(null, true, true);
-        // For correct results, close open filled paths with straight lines:
-        if (resolve && res.hasFill()) {
+        if (resolve) {
+            // For correct results, close open paths with straight lines:
             var paths = getPaths(res);
             for (var i = 0, l = paths.length; i < l; i++) {
                 var path = paths[i];
-                if (!path._closed) {
+                if (!path._closed && !path.isEmpty()) {
                     // Close with epsilon tolerance, to avoid tiny straight
                     // that would cause issues with intersection detection.
                     path.closePath(/*#=*/Numerical.EPSILON);
@@ -74,12 +74,11 @@ PathItem.inject(new function() {
                     path.getLastSegment().setHandleOut(0, 0);
                 }
             }
-        }
-        return resolve
-            ? res
+            res = res
                 .resolveCrossings()
-                .reorient(res.getFillRule() === 'nonzero', true)
-            : res;
+                .reorient(res.getFillRule() === 'nonzero', true);
+        }
+        return res;
     }
 
     function createResult(paths, simplify, path1, path2, options) {
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index 292bede7..1da22b66 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -888,7 +888,7 @@ test('#1221', function() {
     compareBoolean(function() { return blob.subtract(rect2, { trace: false }); },
         'M534,273c-29.65069,-13.2581 -57.61955,-25.39031 -84,-36.46967M150,138.13156c-71.67127,-11.53613 -105.25987,0.10217 -120,19.86844c-40.5,54.3 31.5,210.2 111,222c3.08303,0.45637 6.07967,0.68158 9,0.69867M409.85616,400c18.87105,20.95032 39.82014,38.41763 69.14384,42c33.8,4.1 83.1,-9.7 150,-90');
     compareBoolean(function() { return blob.subtract(rect2, { trace: true }); },
-        'M629,352c-66.9,80.3 -116.2,94.1 -150,90c-29.3237,-3.58237 -50.27279,-21.04968 -69.14384,-42h40.14384v-163.46967c26.38045,11.07937 54.34931,23.21157 84,36.46967M141,380c-79.5,-11.8 -151.5,-167.7 -111,-222c14.74013,-19.76627 48.32873,-31.40457 120,-19.86844v242.56712c-2.92033,-0.01709 -5.91697,-0.24231 -9,-0.69867z');
+        'M629,352c-66.9,80.3 -116.2,94.1 -150,90c-29.3237,-3.58237 -50.27279,-21.04968 -69.14384,-42h40.14384v-163.46967c26.38045,11.07937 54.34931,23.21157 84,36.46967zM141,380c-79.5,-11.8 -151.5,-167.7 -111,-222c14.74013,-19.76627 48.32873,-31.40457 120,-19.86844v242.56712c-2.92033,-0.01709 -5.91697,-0.24231 -9,-0.69867z');
 
     var rect3 = new Path.Rectangle({
         point: [150, 100],
@@ -898,8 +898,7 @@ test('#1221', function() {
     compareBoolean(function() { return blob.subtract(rect3, { trace: false }); },
         'M534,273c-29.65069,-13.2581 -57.61955,-25.39031 -84,-36.46967M150,138.13156c-71.67127,-11.53613 -105.25987,0.10217 -120,19.86844c-40.5,54.3 31.5,210.2 111,222c60.8,9 88,-71.9 159,-66c81.6,6.8 99.6,118.3 179,128c33.8,4.1 83.1,-9.7 150,-90');
     compareBoolean(function() { return blob.subtract(rect3, { trace: true }); },
-        'M629,352c-66.9,80.3 -116.2,94.1 -150,90c-79.4,-9.7 -97.4,-121.2 -179,-128c-71,-5.9 -98.2,75 -159,66c-79.5,-11.8 -151.5,-167.7 -111,-222c14.74013,-19.76627 48.32873,-31.40457 120,-19.86844v111.86844h300v-13.46967c26.38045,11.07937 54.34931,23.21157 84,36.46967');
-
+        'M629,352c-66.9,80.3 -116.2,94.1 -150,90c-79.4,-9.7 -97.4,-121.2 -179,-128c-71,-5.9 -98.2,75 -159,66c-79.5,-11.8 -151.5,-167.7 -111,-222c14.74013,-19.76627 48.32873,-31.40457 120,-19.86844v111.86844h300v-13.46967c26.38045,11.07937 54.34931,23.21157 84,36.46967z');
 
     var rect4 = new Path.Rectangle({
         point: [200, 200],
@@ -1219,7 +1218,7 @@ test('#1419', function() {
 test('#1351', function() {
     var path1 = new CompoundPath(new Path([10, 10], [100, 100]), new Path([150, 25]));
     var path2 = new Path([20, 80], [80, 20]);
-    var result = 'M10,10l40,40l50,50';
+    var result = ''; // empty!
     compareBoolean(path1.unite(path2), result);
 });
 

From b51a4bed57be5827a730be8c6eb3d5e03fc13666 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 04:48:05 +0200
Subject: [PATCH 125/181] Change winding quality handling when on starting
 point

---
 src/path/PathItem.Boolean.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 02caa192..31783fb9 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -593,9 +593,7 @@ PathItem.inject(new function() {
                         onPath = true;
                     }
                 }
-                // TODO: Determine how to handle quality when curve is crossed
-                // at starting point. Do we always need to set to 0?
-                quality = 0;
+                quality /= 4;
             }
             vPrev = v;
             // If we're on the curve, look at the tangent to decide whether to

From 7f496408b55343c193b8c5c0c16996d769596278 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 10:26:47 +0200
Subject: [PATCH 126/181] Crossing detection: Revert boundary checks

Adjust ambiguous edge case test instead
---
 src/path/CurveLocation.js        | 4 ++--
 test/tests/Path_Intersections.js | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 7d6dd9df..bd84cfd8 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -460,9 +460,9 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
 
         function isInRange(angle, min, max) {
             return min < max
-                    ? angle > min && angle <= max
+                    ? angle > min && angle < max
                     // min > max: the range wraps around -180 / 180 degrees
-                    : angle > min || angle <= max;
+                    : angle > min || angle < max;
         }
 
         if (!t1Inside) {
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 370bbf8d..46100e6d 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -201,7 +201,7 @@ test('#1073#issuecomment-234305530', function() {
         true]);
     testIntersections(path1.getIntersections(path2), [
         { point: { x: 426.61172, y: 448 }, index: 0, time: 0.27769, crossing: true },
-        { point: { x: 376, y: 480 }, index: 1, time: 0, crossing: true },
+        { point: { x: 376, y: 480 }, index: 1, time: 0, crossing: false },
         { point: { x: 343.68011, y: 469.7389 }, index: 1, time: 0.77843, crossing: true },
         { point: { x: 336.40125, y: 463.59875 }, index: 2, time: 0.00608, crossing: true }
     ]);

From bba70907e79af3e990341493eb2aaf8c4f700f25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 10:27:31 +0200
Subject: [PATCH 127/181] Fix PathItem#isCrossing() to not return overlaps

Closes #1409
---
 src/path/PathItem.Boolean.js     | 17 ++++++++++++++---
 src/path/PathItem.js             |  9 +--------
 test/tests/Path_Intersections.js | 20 ++++++++++++++++++++
 3 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 31783fb9..a38aac3d 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -97,6 +97,17 @@ PathItem.inject(new function() {
         return result;
     }
 
+    function filterIntersection(inter) {
+        // TODO: Change isCrossing() to also handle overlaps (hasOverlap())
+        // that are actually involved in a crossing! For this we need proper
+        // overlap range detection / merging first... But as we call
+        // #resolveCrossings() first in boolean operations, removing all
+        // self-touching areas in paths, this works for the known use cases.
+        // The ideal implementation would deal with it in a way outlined in:
+        // https://github.com/paperjs/paper.js/issues/874#issuecomment-168332391
+        return inter.hasOverlap() || inter.isCrossing();
+    }
+
     function traceBoolean(path1, path2, operation, options) {
         // Only support subtract and intersect operations when computing stroke
         // based boolean operations (options.split = true).
@@ -121,8 +132,8 @@ PathItem.inject(new function() {
             _path2.reverse();
         // Split curves at crossings on both paths. Note that for self-
         // intersection, path2 is null and getIntersections() handles it.
-        var crossings = divideLocations(
-                CurveLocation.expand(_path1.getCrossings(_path2))),
+        var crossings = divideLocations(CurveLocation.expand(
+                _path1.getIntersections(_path2, filterIntersection))),
             paths1 = getPaths(_path1),
             paths2 = _path2 && getPaths(_path2),
             segments = [],
@@ -182,7 +193,7 @@ PathItem.inject(new function() {
     function splitBoolean(path1, path2, operation) {
         var _path1 = preparePath(path1),
             _path2 = preparePath(path2),
-            crossings = _path1.getCrossings(_path2),
+            crossings = _path1.getIntersections(_path2, filterIntersection),
             subtract = operation === 'subtract',
             divide = operation === 'divide',
             added = {},
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index e7ff2d17..01000361 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -351,14 +351,7 @@ var PathItem = Item.extend(/** @lends PathItem# */{
      */
     getCrossings: function(path) {
         return this.getIntersections(path, function(inter) {
-            // TODO: Only return overlaps that are actually crossings! For this
-            // we need proper overlap range detection / merging first...
-            // But as we call #resolveCrossings() first in boolean operations,
-            // removing all self-touching areas in paths, this currently works
-            // as it should in the known use cases.
-            // The ideal implementation would deal with it in a way outlined in:
-            // https://github.com/paperjs/paper.js/issues/874#issuecomment-168332391
-            return inter.hasOverlap() || inter.isCrossing();
+            return inter.isCrossing();
         });
     },
 
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 46100e6d..71de7ca9 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -380,3 +380,23 @@ test('#1262', function() {
         { point: { x: 567.05562, y: 634.62043 }, time: 1 }
     ]);
 });
+
+test('#1409', function() {
+    var path1 = new Path({
+        segments: [[20, 20], [20, 80], [80, 80], [80, 20]],
+        closed: true
+    });
+    var path2 = new Path({
+        segments: [[80, 20], [80, 80], [140, 80], [140, 20]],
+        closed: true
+    });
+    testIntersections(path1.getCrossings(path2), []);
+
+    var rect1  = new Path.Rectangle(new Point(100, 100), new Size(100, 100));
+    var rect2 = rect1.clone();
+    testIntersections(rect1.getCrossings(rect2), []);
+
+    var circ1 = new Path.Circle(new Point(300,300), 40);
+    var circ2 = circ1.clone();
+    testIntersections(circ1.getCrossings(circ2), []);
+});

From 652574115c3307e6b8f69af49cf820b53153becd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 23 Jun 2019 10:30:56 +0200
Subject: [PATCH 128/181] Implement unit test for #1255

This appears to have been fixed in the meantime.
Closes #1255
---
 test/tests/Path_Intersections.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 71de7ca9..2126dac6 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -400,3 +400,11 @@ test('#1409', function() {
     var circ2 = circ1.clone();
     testIntersections(circ1.getCrossings(circ2), []);
 });
+
+test('#1255', function() {
+    var c1 = new Curve([439.3824078319993,216.13903749801196],[-0.06618902689025684,-11.053567490673387],[-9.709467619869528,5.2831783801853],[455.0432856400729,189.60783460905492]);
+    var c2 = new Curve([446.1268928788026,138.78016797936476],[-4.688929299417313,19.846766368483937],[-0.19057652660425625,-31.82627994291222],[439.3824078319993,216.13903749801196]);
+    testIntersections(c1.getIntersections(c2), [
+        { point: { x: 439.38241, y: 216.13904 }, time: 0, crossing: false }
+    ]);
+});

From cc15696750035ab00e00c64c7c95daa2c85efe01 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Mon, 1 Jul 2019 11:16:07 +0200
Subject: [PATCH 129/181] Fix some documentation return types (#1679)

---
 src/core/PaperScope.js | 1 +
 src/item/Item.js       | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 2d4f9670..1b6bf757 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -311,6 +311,7 @@ var PaperScope = Base.extend(/** @lends PaperScope# */{
              * Retrieves a PaperScope object with the given scope id.
              *
              * @param id
+             * @return {PaperScope}
              */
             get: function(id) {
                 return this._scopes[id] || null;
diff --git a/src/item/Item.js b/src/item/Item.js
index 1a9d483a..2e0dfe4b 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2854,7 +2854,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @param {Boolean} [recursively=false] whether an item with children should be
      * considered empty if all its descendants are empty
-     * @return Boolean
+     * @return {Boolean}
      */
     isEmpty: function(recursively) {
         var children = this._children;

From 0c885964d3bf2ac3c3c35ac9c99755c36b13e68c Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Fri, 12 Jul 2019 11:52:53 +0200
Subject: [PATCH 130/181] Add support for nullable in documentation

---
 .../typescript-definition-generator.js        | 49 ++++++++++++++-----
 src/anim/Tween.js                             |  2 +-
 src/item/HitResult.js                         |  2 +-
 src/item/Item.js                              | 26 +++++-----
 src/item/Raster.js                            |  4 +-
 src/style/Style.js                            |  8 +--
 src/tool/Tool.js                              | 12 ++---
 src/view/View.js                              | 20 ++++----
 8 files changed, 75 insertions(+), 48 deletions(-)

diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
index 7a8df070..17968665 100644
--- a/gulp/typescript/typescript-definition-generator.js
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -154,13 +154,41 @@ function parseType(type, options) {
     // `...` prefix and add `[]` as a suffix:
     // - `...Type` => `Type[]`
     // - `...(TypeA|TypeB)` => `(TypeA|TypeB)[]`
-    const isRestType = type.startsWith('...');
-    if (isRestType) {
-        type = type.replace(/^\.\.\./, '');
+    const restPattern = /^\.\.\./;
+    const isRest = type.match(restPattern);
+    if (isRest) {
+        type = type.replace(restPattern, '');
     }
+    const wrappedPattern = /^\(([^\)]+)\)$/;
+    const isWrapped = type.match(wrappedPattern);
+    if (isWrapped) {
+        type = type.replace(wrappedPattern, '$1');
+    }
+
+
     // Handle multiple types possibility by splitting on `|` then re-joining
     // back parsed types.
-    type = type.split('|').map(splittedType => {
+    const types = type.split('|');
+
+    // Hanle nullable type:
+    // - `?Type` => `Type|null`
+    // - `?TypeA|TypeB` => `TypeA|TypeB|null`
+    // - `?TypeA|?TypeB` => `TypeA|TypeB|null`
+    // If at least one type is nullable, we add null type at the end of the
+    // list.
+    const nullablePattern = /^\?/;
+    let isNullable = false;
+    for (let i = 0; i < types.length; i++) {
+        if (types[i].match(nullablePattern)) {
+            types[i] = types[i].replace(nullablePattern, '');
+            isNullable = true;
+        }
+    }
+    if (isNullable) {
+        types.push('null');
+    }
+
+    type = types.map(splittedType => {
         // Get type without array suffix `[]` for easier matching.
         const singleType = splittedType.replace(/(\[\])+$/, '');
         // Handle eventual type conflict in static constructors block. For
@@ -185,14 +213,13 @@ function parseType(type, options) {
         }
         return splittedType;
     }).join(' | ');
-    if (isRestType) {
-        type += '[]';
-    }
 
-    // We declare settable properties as nullable to be compatible with
-    // TypeScript `strictNullChecks` option (#1664).
-    if (options.isSettableProperty && type !== 'any') {
-        type += ' | null';
+    // Regroup types.
+    if (isWrapped) {
+        type = `(${type})`;
+    }
+    if (isRest) {
+        type += '[]';
     }
 
     return type;
diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index 790fee86..765efa01 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -265,7 +265,7 @@ var Tween = Base.extend(Emitter, /** @lends Tween# */{
      *
      * @name Tween#onUpdate
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Display tween progression values:
diff --git a/src/item/HitResult.js b/src/item/HitResult.js
index ee804160..253dc16b 100644
--- a/src/item/HitResult.js
+++ b/src/item/HitResult.js
@@ -75,7 +75,7 @@ var HitResult = Base.extend(/** @lends HitResult# */{
      *
      * @name HitResult#color
      * @property
-     * @type Color
+     * @type ?Color
      */
 
     /**
diff --git a/src/item/Item.js b/src/item/Item.js
index 2e0dfe4b..96636702 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -3081,7 +3081,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#strokeColor
      * @property
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Setting the stroke color of a path:
@@ -3243,7 +3243,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#fillColor
      * @property
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Setting the fill color of a path to red:
@@ -3277,7 +3277,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @property
      * @name Item#shadowColor
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Creating a circle with a black shadow:
@@ -3323,7 +3323,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#selectedColor
      * @property
-     * @type Color
+     * @type ?Color
      */
 }, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
     var rotate = key === 'rotate';
@@ -3769,7 +3769,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onFrame
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onFrame
      *
      * @example {@paperscript}
@@ -3796,7 +3796,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseDown
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseDown
      *
      * @example {@paperscript}
@@ -3846,7 +3846,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseDrag
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseDrag
      *
      * @example {@paperscript height=240}
@@ -3875,7 +3875,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseUp
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseUp
      *
      * @example {@paperscript}
@@ -3905,7 +3905,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onClick
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onClick
      *
      * @example {@paperscript}
@@ -3955,7 +3955,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onDoubleClick
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onDoubleClick
      *
      * @example {@paperscript}
@@ -4005,7 +4005,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseMove
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseMove
      *
      * @example {@paperscript}
@@ -4036,7 +4036,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseEnter
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseEnter
      *
      * @example {@paperscript}
@@ -4098,7 +4098,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#onMouseLeave
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseLeave
      *
      * @example {@paperscript}
diff --git a/src/item/Raster.js b/src/item/Raster.js
index ee279d96..d9f22677 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -763,7 +763,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#onLoad
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example
      * var url = 'http://assets.paperjs.org/images/marilyn.jpg';
@@ -789,7 +789,7 @@ var Raster = Item.extend(/** @lends Raster# */{
      *
      * @name Raster#onError
      * @property
-     * @type Function
+     * @type ?Function
      */
 
     _getBounds: function(matrix, options) {
diff --git a/src/style/Style.js b/src/style/Style.js
index b30e090a..a9a8399d 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -411,7 +411,7 @@ var Style = Base.extend(new function() {
      *
      * @name Style#strokeColor
      * @property
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Setting the stroke color of a path:
@@ -568,7 +568,7 @@ var Style = Base.extend(new function() {
      *
      * @name Style#fillColor
      * @property
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Setting the fill color of a path to red:
@@ -599,7 +599,7 @@ var Style = Base.extend(new function() {
      *
      * @property
      * @name Style#shadowColor
-     * @type Color
+     * @type ?Color
      *
      * @example {@paperscript}
      * // Creating a circle with a black shadow:
@@ -643,7 +643,7 @@ var Style = Base.extend(new function() {
      *
      * @name Style#selectedColor
      * @property
-     * @type Color
+     * @type ?Color
      */
 
     /**
diff --git a/src/tool/Tool.js b/src/tool/Tool.js
index 69699f09..05110788 100644
--- a/src/tool/Tool.js
+++ b/src/tool/Tool.js
@@ -135,7 +135,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onMouseDown
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Creating circle shaped paths where the user presses the mouse button:
@@ -157,7 +157,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onMouseDrag
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Draw a line by adding a segment to a path on every mouse drag event:
@@ -180,7 +180,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onMouseMove
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Moving a path to the position of the mouse:
@@ -206,7 +206,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onMouseUp
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Creating circle shaped paths where the user releases the mouse:
@@ -234,7 +234,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onKeyDown
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example {@paperscript}
      * // Scaling a path whenever the user presses the space bar:
@@ -268,7 +268,7 @@ var Tool = PaperScopeItem.extend(/** @lends Tool# */{
      *
      * @name Tool#onKeyUp
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example
      * tool.onKeyUp = function(event) {
diff --git a/src/view/View.js b/src/view/View.js
index 13291df6..6e45717c 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -746,7 +746,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onFrame
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onFrame
      *
      * @example {@paperscript}
@@ -768,7 +768,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onResize
      * @property
-     * @type Function
+     * @type ?Function
      *
      * @example
      * // Repositioning items when a view is resized:
@@ -793,7 +793,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseDown
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onMouseDown
      */
 
@@ -807,7 +807,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseDrag
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onMouseDrag
      */
 
@@ -818,7 +818,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseUp
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onMouseUp
      */
 
@@ -832,7 +832,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onClick
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onClick
      */
 
@@ -846,7 +846,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onDoubleClick
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onDoubleClick
      */
 
@@ -860,7 +860,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseMove
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onMouseMove
      */
 
@@ -875,7 +875,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseEnter
      * @property
-     * @type Function
+     * @type ?Function
      * @see Item#onMouseEnter
      */
 
@@ -889,7 +889,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#onMouseLeave
      * @property
-     * @type Function
+     * @type ?Function
      * @see View#onMouseLeave
      */
 

From c9a8d54623402d615d2ccc5af3ab6b8decb99646 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 12 Jul 2019 11:57:33 +0200
Subject: [PATCH 131/181] Update JSDoc for #1677

---
 gulp/jsdoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gulp/jsdoc b/gulp/jsdoc
index 4e89b701..1d389681 160000
--- a/gulp/jsdoc
+++ b/gulp/jsdoc
@@ -1 +1 @@
-Subproject commit 4e89b70137883c0ab6fc24986cc6452362568ddb
+Subproject commit 1d38968146973a4bb10f5495b73c9d5dd46188d7

From aec1c2c138ce1f5b8b5a65589ef88bef1d1436e0 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Fri, 12 Jul 2019 12:06:26 +0200
Subject: [PATCH 132/181] Fix SymbolItem#hitTestAll()

Closes #1680
---
 src/item/SymbolItem.js   |  9 +++++++++
 test/tests/SymbolItem.js | 15 +++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 437789f2..1a95a3a8 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -121,7 +121,16 @@ var SymbolItem = Item.extend(/** @lends SymbolItem# */{
     },
 
     _hitTestSelf: function(point, options, viewMatrix) {
+        // We need to call definition item hit test with `options.all`
+        // disabled, otherwise it would populate the array with its own
+        // matches. What we want instead is only returning one match per symbol
+        // item (#1680). So we store original matches array...
+        var all = options.all;
+        // ...we temporarily disable `options.all`...
+        delete options.all;
         var res = this._definition._item._hitTest(point, options, viewMatrix);
+        // ...then after hit testing, we restore the original matches array.
+        options.all = all;
         // TODO: When the symbol's definition is a path, should hitResult
         // contain information like HitResult#curve?
         if (res)
diff --git a/test/tests/SymbolItem.js b/test/tests/SymbolItem.js
index 9e3ba191..7eb82ba1 100644
--- a/test/tests/SymbolItem.js
+++ b/test/tests/SymbolItem.js
@@ -143,3 +143,18 @@ test('SymbolItem#bounds with #applyMatrix = false', function() {
     equals(function() { return placed.bounds; },
         { x: 150, y: 150, width: 100, height: 100 });
 });
+
+test('SymbolItem#hitTestAll', function() {
+    var symbol = new SymbolDefinition(
+        new Path.Circle({
+            center: [0, 0],
+            radius: 10,
+            fillColor: 'orange'
+        })
+    );
+    var symbolItem = symbol.place([50, 50]);
+
+    var hitTestAll = symbolItem.hitTestAll([50, 50]);
+    equals(hitTestAll.length, 1);
+    equals(hitTestAll[0].item.id, symbolItem.id);
+});

From 0bb04fffffb67f7dc0bf623485119c1b948e68d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 12 Jul 2019 12:14:22 +0200
Subject: [PATCH 133/181] Simplify fix for #1685

Create `Base` objects for options, so `extend()` can be used to override properties in a fast and nondestructive manner.
---
 src/item/HitResult.js  |  2 +-
 src/item/Item.js       |  4 ++--
 src/item/SymbolItem.js | 15 +++++----------
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/item/HitResult.js b/src/item/HitResult.js
index 253dc16b..bb51f333 100644
--- a/src/item/HitResult.js
+++ b/src/item/HitResult.js
@@ -105,7 +105,7 @@ var HitResult = Base.extend(/** @lends HitResult# */{
          */
         getOptions: function(args) {
             var options = args && Base.read(args);
-            return Base.set({
+            return new Base({
                 // Type of item, for instanceof check: Group, Layer, Path,
                 // CompoundPath, Shape, Raster, SymbolItem, ...
                 type: null,
diff --git a/src/item/Item.js b/src/item/Item.js
index 96636702..99b2b823 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1818,7 +1818,7 @@ new function() { // Injection scope for various item event handlers
         // See CompoundPath#_contains() for the reason for !!
         var matrix = this._matrix;
         return (
-            matrix.isInvertible() && 
+            matrix.isInvertible() &&
             !!this._contains(matrix._inverseTransform(Point.read(arguments)))
         );
     },
@@ -1886,7 +1886,7 @@ new function() { // Injection scope for hit-test functions shared with project
         var point = Point.read(arguments),
             options = HitResult.getOptions(arguments),
             all = [];
-        this._hitTest(point, Base.set({ all: all }, options));
+        this._hitTest(point, new Base({ all: all }, options));
         return all;
     }
 
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 1a95a3a8..01b6a779 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -121,16 +121,11 @@ var SymbolItem = Item.extend(/** @lends SymbolItem# */{
     },
 
     _hitTestSelf: function(point, options, viewMatrix) {
-        // We need to call definition item hit test with `options.all`
-        // disabled, otherwise it would populate the array with its own
-        // matches. What we want instead is only returning one match per symbol
-        // item (#1680). So we store original matches array...
-        var all = options.all;
-        // ...we temporarily disable `options.all`...
-        delete options.all;
-        var res = this._definition._item._hitTest(point, options, viewMatrix);
-        // ...then after hit testing, we restore the original matches array.
-        options.all = all;
+        // We need to call definition item hit test with `options.all = false`,
+        // as otherwise it would populate the array with its own matches.
+        // Instead we want only returning one match per symbol-item, see #1680
+        var opts = options.extend({ all: false });
+        var res = this._definition._item._hitTest(point, opts, viewMatrix);
         // TODO: When the symbol's definition is a path, should hitResult
         // contain information like HitResult#curve?
         if (res)

From 3e5d4fa1c6dcf023d0543e1d4165cc72c3866674 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 12 Jul 2019 12:41:15 +0200
Subject: [PATCH 134/181] Remove Bower instructions and clean up README

---
 README.md | 58 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 31 insertions(+), 27 deletions(-)

diff --git a/README.md b/README.md
index 97f720a1..d82ec3f1 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Paper.js - The Swiss Army Knife of Vector Graphics Scripting [![Build Status](https://travis-ci.org/paperjs/paper.js.svg?branch=develop)](https://travis-ci.org/paperjs/paper.js) [![NPM](https://img.shields.io/npm/v/paper.svg)](https://www.npmjs.com/package/paper) ![Bower](https://img.shields.io/bower/v/paper.svg)
+# Paper.js - The Swiss Army Knife of Vector Graphics Scripting [![Build Status](https://travis-ci.org/paperjs/paper.js.svg?branch=develop)](https://travis-ci.org/paperjs/paper.js) [![NPM](https://img.shields.io/npm/v/paper.svg)](https://www.npmjs.com/package/paper)
 
 If you want to work with Paper.js, simply download the latest "stable" version
 from [http://paperjs.org/download/](http://paperjs.org/download/)
@@ -18,24 +18,22 @@ from [http://paperjs.org/download/](http://paperjs.org/download/)
 
 The recommended way to install and maintain Paper.js as a dependency in your
 project is through the [Node.js Package Manager (NPM)](https://www.npmjs.com/)
-for browsers, Node.js or Electron, as well as through Bower for browsers.
+for browsers, Node.js or Electron.
 
-If NPM or Bower is already installed, simply type one of these
-commands in your project folder:
+If NPM is already installed, simply type one of these commands in your project
+folder:
 
 ```sh
 npm install paper
-# Or:
-bower install paper
 ```
 
 Upon execution, you will find a `paper` folder inside the project's
-`node_modules` / `bower_components` folder.
+`node_modules` folder.
 
 For more information on how to install Node.js and NPM, read the chapter
 [Installing Node.js and NPM](#installing-nodejs-and-npm).
 
-### Which Version to Use?
+### Which Version to Use
 
 The various distributions come with two different pre-build versions of
 Paper.js, in minified and normal variants:
@@ -69,7 +67,7 @@ rendering to the Canvas on Node.js, as described in the next paragraph.
 For Linux, see <https://nodejs.org/download/> to locate 32-bit and 64-bit Node.js
 binaries as well as sources, or use NVM, as described in the paragraph above.
 
-### Installing Paper.js for Node.js
+### Installing Paper.js Using NPM
 
 Paper.js comes in three different versions on NPM: `paper`, `paper-jsdom` and
 `paper-jsdom-canvas`. Depending on your use case, you need to required a
@@ -86,10 +84,17 @@ different one:
 In order to install `paper-jsdom-canvas`, you need the [Cairo Graphics
 library](https://cairographics.org/) installed in your system:
 
-##### Installing Cairo and Pango on macOS:
+### Installing Native Dependencies
 
-The easiest way to install Cairo is through [Homebrew](https://brew.sh/), by
-issuing the command:
+Paper.js relies on [Node-Canvas](https://github.com/Automattic/node-canvas) for
+rendering, which in turn relies on the native libraries
+[Cairo](https://cairographics.org/) and [Pango](https://www.pango.org/).
+
+#### Installing Native Dependencies on macOS
+
+Paper.js relies on Node-Canvas for rendering, which in turn relies on Cairo and
+Pango. The easiest way to install Cairo is through
+[Homebrew](https://brew.sh/), by issuing the command:
 
     brew install cairo pango
 
@@ -113,7 +118,7 @@ After adding this line, your commands should work in the expected way:
     npm install paper
     npm update
 
-##### Installing Cairo, Pango and all other dependencies on Debian/Ubuntu Linux:
+#### Installing Native Dependencies on Debian/Ubuntu Linux
 
     sudo apt-get install pkg-config libcairo2-dev libpango1.0-dev libssl-dev libjpeg62-dev libgif-dev
 
@@ -122,24 +127,23 @@ build from c++ sources:
 
     sudo apt-get install build-essential
 
-##### After Cairo has been installed:
+#### Installing Native Dependencies for Electron
+
+In order to build Node-Canvas for use of `paper-jsdom-canvas` in Electron, which
+is likely to use a different version of V8 than the Node binary installed in
+your system, you need to manually specify the location of Electron’s headers.
+Follow these steps to do so:
+
+[Electron — Using Native Node
+Modules](https://electron.atom.io/docs/tutorial/using-native-node-modules/)
+
+#### After Native Dependencies have been installed
 
 You should now be able to install the Paper.js module with jsdom and Canvas
 rendering from NPM:
 
     npm install paper-jsdom-canvas
 
-### Installing Paper.js with Node-Canvas for Electron
-
-[Node-Canvas](https://github.com/Automattic/node-canvas) is a native dependency.
-In order to build it for use of `paper-jsdom-canvas` in Electron, which is
-likely to use a different version of V8 than the Node binary installed in your
-system, you need to manually specify the location of Electron’s headers. Follow
-these steps to do so:
-
-[Electron — Using Native Node
-Modules](https://electron.atom.io/docs/tutorial/using-native-node-modules/)
- 
 ## Development
 
 The main Paper.js source tree is hosted on
@@ -164,8 +168,8 @@ run:
 ### Setting Up For Building
 
 As of 2016, Paper.js uses [Gulp.js](https://gulpjs.com/) for building, and has a
-couple of dependencies as Bower and NPM modules. Read the chapter [Installing
-Node.js, NPM and Bower](#installing-nodejs-npm-and-bower) if you still need to
+couple of dependencies as NPM modules. Read the chapter [Installing
+Node.js and NPM](#installing-nodejs-and-npm) if you still need to
 install these.
 
 In order to be able to build Paper.js, after checking out the repository, paper

From aa9dc86e7bc210bb7e4e0215bd34240e93636462 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Mon, 12 Aug 2019 16:24:29 +0200
Subject: [PATCH 135/181] Fix issue template typo (#1704)

---
 .github/ISSUE_TEMPLATE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index dbd9148a..abe9d9a2 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,7 +1,7 @@
 <!--
 This issues database is used to keep track of bugs and new features.
 For questions and support, please visit the Gitter channel instead:
-  https://gitter.im/Vincit/objection.js
+  https://gitter.im/paperjs/paper.js
 -->
 
 # Description/Steps to reproduce

From f84199c83db23b00cd6ac693112bf50b54cbf50c Mon Sep 17 00:00:00 2001
From: sasensi <asensi.samuel@gmail.com>
Date: Sun, 6 Oct 2019 14:00:09 +0200
Subject: [PATCH 136/181] Fix: nested group matrix should not be reset

When a group had `applyMatrix` set to `false`, when its parent's matrix
was applied, its matrix was applied to its children then it was reset.
This makes sure that in this case, parent matrix is only added to child
matrix but not applied to child's children and that child's matrix is
not reset.
Closes #1711
---
 src/item/Item.js    | 33 +++++++++++++++++----------------
 test/tests/Group.js | 10 ++++++++++
 2 files changed, 27 insertions(+), 16 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 99b2b823..3a45d61e 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -3549,24 +3549,25 @@ new function() { // Injection scope for hit-test functions shared with project
             if (strokeColor)
                 strokeColor.transform(matrix);
         }
-        // Call #_transformContent() now, if we need to directly apply the
-        // internal _matrix transformations to the item's content.
-        // Application is not possible on Raster, PointText, SymbolItem, since
-        // the matrix is where the actual transformation state is stored.
-        if (applyMatrix && (applyMatrix = this._transformContent(_matrix,
-                _applyRecursively, _setApplyMatrix))) {
-            // Pivot is provided in the parent's coordinate system, so transform
-            // it along too.
-            var pivot = this._pivot;
-            if (pivot)
-                _matrix._transformPoint(pivot, pivot, true);
-            // Reset the internal matrix to the identity transformation if
-            // it was possible to apply it, but do not notify owner of change.
-            _matrix.reset(true);
-            // Set the internal _applyMatrix flag to true if we're told to
-            // do so
+        if (applyMatrix) {
+            // Set the internal _applyMatrix flag to true if we're told to do so.
             if (_setApplyMatrix && this._canApplyMatrix)
                 this._applyMatrix = true;
+            // Call #_transformContent() now, if we need to directly apply the
+            // internal _matrix transformations to the item's content.
+            // Application is not possible on Raster, PointText, SymbolItem, since
+            // the matrix is where the actual transformation state is stored.
+            if (this._applyMatrix && (applyMatrix = this._transformContent(_matrix,
+                    _applyRecursively, _setApplyMatrix))) {
+                // Pivot is provided in the parent's coordinate system, so transform
+                // it along too.
+                var pivot = this._pivot;
+                if (pivot)
+                    _matrix._transformPoint(pivot, pivot, true);
+                // Reset the internal matrix to the identity transformation if
+                // it was possible to apply it, but do not notify owner of change.
+                _matrix.reset(true);
+            }
         }
         // Calling _changed will clear _bounds and _position, but depending
         // on matrix we can calculate and set them again, so preserve them.
diff --git a/test/tests/Group.js b/test/tests/Group.js
index e1e47153..55ab101a 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -189,3 +189,13 @@ test(
         equals(group.internalBounds, expected);
     }
 );
+
+test('group.matrix with parent matrix applied (#1711)', function() {
+    var child = new Group({ applyMatrix: false });
+    var parent = new Group([child]);
+    var scale = 1.1;
+    var initial = child.scaling.x;
+    parent.scale(scale);
+    var final = child.scaling.x;
+    equals(final, initial * scale);
+});

From f0b8799c95a283ce5c1bf2397ad3ccd2e1bfd54c Mon Sep 17 00:00:00 2001
From: Aditya <adi004.zz@gmail.com>
Date: Wed, 14 Aug 2019 15:00:17 +0530
Subject: [PATCH 137/181] fix: raster extend

The extend function was not working properly (_serializeFields were affected).
---
 src/item/Raster.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index d9f22677..6453fe0f 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -18,7 +18,6 @@
  * @extends Item
  */
 var Raster = Item.extend(/** @lends Raster# */{
-}, /** @lends Raster# */{
     _class: 'Raster',
     _applyMatrix: false,
     _canApplyMatrix: false,

From 43bbb249ab8e7afa34b410f5515e0e93dc2414dd Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Thu, 7 Nov 2019 12:12:14 +0100
Subject: [PATCH 138/181] Allow paper core import in TypeScript (#1716)

* Allow paper core import in TypeScript

Typings were missing when importing paper core version with:
`import * as paper from 'paper/dist/paper-core'` syntax.
This changes the generated TypeScript definition so that it exports two
modules: `paper` and `paper/dist/paper-core`. In the same logic,
`paper-core.d.ts` file is added to make sure that the corresponding
definition is automatically loaded.
This also takes care of the fact that `PaperScript` class is not
available in paper core version, by removing it from the corresponding
TypeScript definition.
Finally, this also simplifies existing definition by directly exporting
a `PaperScope` instance as the module instead of duplicating all
`PaperScope` properties and methods on the module itself.
Closes #1713
---
 dist/paper-core.d.ts                          |  1 +
 gulp/tasks/dist.js                            |  1 +
 .../typescript-definition-generator.js        | 13 ++-------
 .../typescript-definition-template.mustache   | 29 ++++++++-----------
 4 files changed, 16 insertions(+), 28 deletions(-)
 create mode 100644 dist/paper-core.d.ts

diff --git a/dist/paper-core.d.ts b/dist/paper-core.d.ts
new file mode 100644
index 00000000..2fccf70e
--- /dev/null
+++ b/dist/paper-core.d.ts
@@ -0,0 +1 @@
+import './paper';
diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index e69e861c..1cf2d950 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -23,6 +23,7 @@ gulp.task('zip', ['clean:zip', 'dist'], function() {
                 'dist/paper-full*.js',
                 'dist/paper-core*.js',
                 'dist/paper.d.ts',
+                'dist/paper-core.d.ts',
                 'dist/node/**/*',
                 'LICENSE.txt',
                 'examples/**/*',
diff --git a/gulp/typescript/typescript-definition-generator.js b/gulp/typescript/typescript-definition-generator.js
index 17968665..d9e94b4e 100644
--- a/gulp/typescript/typescript-definition-generator.js
+++ b/gulp/typescript/typescript-definition-generator.js
@@ -91,21 +91,12 @@ classes.forEach(cls => {
 // PaperScope class needs to be handled slightly differently because it "owns"
 // all the other classes as properties. Eg. we can do `new paperScope.Path()`.
 // So we add a `classesPointers` property that the template will use.
-const paperScopeClass = classes.find(_ => _.className === 'PaperScope');
-paperScopeClass.classesPointers = classes.filter(_ => _.className !== 'PaperScope').map(_ => ({ name: _.className }));
-
-// Since paper.js module is at the same time a PaperScope instance, we need to
-// duplicate PaperScope instance properties and methods in the module scope.
-// For that, we expose a special variable to the template.
-const paperInstance = { ...paperScopeClass };
-// We filter static properties and methods for module scope.
-paperInstance.properties = paperInstance.properties.filter(_ => !_.static);
-paperInstance.methods = paperInstance.methods.filter(_ => !_.static && _.name !== 'constructor');
+const paperScopeClass = classes.find(it => it.className === 'PaperScope');
+paperScopeClass.classesPointers = classes.map(it => ({ name: it.className }));
 
 // Format data trough a mustache template.
 // Prepare data for the template.
 const context = {
-    paperInstance: paperInstance,
     classes: classes,
     version: data.version,
     date: data.date,
diff --git a/gulp/typescript/typescript-definition-template.mustache b/gulp/typescript/typescript-definition-template.mustache
index 3de46bcc..f043f061 100644
--- a/gulp/typescript/typescript-definition-template.mustache
+++ b/gulp/typescript/typescript-definition-template.mustache
@@ -14,21 +14,7 @@
  * This is an auto-generated type definition.
  */
 
-declare module paper {
-    {{#paperInstance}}
-    {{#properties}}
-    {{#doc}}4{{/doc}}
-    let {{name}}{{type}}
-
-    {{/properties}}
-
-    {{#methods}}
-    {{#doc}}4{{/doc}}
-    function {{name}}({{params}}){{type}}
-
-    {{/methods}}
-    {{/paperInstance}}
-
+declare namespace paper {
     {{#classes}}
 
     {{#doc}}4{{/doc}}
@@ -65,6 +51,15 @@ declare module paper {
     {{/classes}}
 }
 
-declare module 'paper' {
-    export = paper
+
+declare module 'paper/dist/paper-core'
+{
+    const paperCore: Pick<paper.PaperScope, Exclude<keyof paper.PaperScope, 'PaperScript'>>;
+    export = paperCore
+}
+
+declare module 'paper'
+{
+    const paperFull: paper.PaperScope;
+    export = paperFull
 }

From 7dad1a495d07e2c91cfffec9e4ea0221e50965f4 Mon Sep 17 00:00:00 2001
From: adroitwhiz <adroitwhiz@protonmail.com>
Date: Sat, 9 Nov 2019 12:17:26 -0500
Subject: [PATCH 139/181] Fix handling of negative Shape sizes (#1733)

---
 src/item/Shape.js   |  2 +-
 test/tests/Shape.js | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/item/Shape.js b/src/item/Shape.js
index fed35b8e..594ceddb 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -90,7 +90,7 @@ var Shape = Item.extend(/** @lends Shape# */{
                 height = size.height;
             if (type === 'rectangle') {
                 // Shrink radius accordingly
-                this._radius.set(Size.min(this._radius, size.divide(2)));
+                this._radius.set(Size.min(this._radius, size.divide(2).abs()));
             } else if (type === 'circle') {
                 // Use average of width and height as new size, then calculate
                 // radius as a number from that:
diff --git a/test/tests/Shape.js b/test/tests/Shape.js
index 3380e92f..83c30bf7 100644
--- a/test/tests/Shape.js
+++ b/test/tests/Shape.js
@@ -53,3 +53,26 @@ test('shape.toPath().toShape()', function() {
         equals(shape.toPath().toShape(), shape, name + '.toPath().toShape()');
     });
 });
+
+test('Shape.Rectangle radius works with negative size', function() {
+    var shape = new Shape.Rectangle({
+        center: [50, 50],
+        size: 50,
+        fillColor: 'black'
+    });
+
+    shape.size = [-25, -25];
+
+    equals(shape.radius.width, 0);
+    equals(shape.radius.height, 0);
+
+    shape.radius = [10, 50];
+    shape.size = [50, -25];
+
+    equals(shape.radius.width, 10);
+    equals(shape.radius.height, 12.5);
+
+    shape.size = [50, 75];
+
+    equals(shape.radius.height, 12.5);
+});

From 871531b46a48ee1a85ede0e0cb78cc5e8fcb3b5a Mon Sep 17 00:00:00 2001
From: sapics <gv.nishino@gmail.com>
Date: Thu, 5 Dec 2019 17:04:03 +0900
Subject: [PATCH 140/181] Fix parsing of rgb color string with percentages

---
 src/style/Color.js  | 2 +-
 test/tests/Color.js | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/style/Color.js b/src/style/Color.js
index 6cf4d737..66293277 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -102,7 +102,7 @@ var Color = Base.extend(new function() {
                     }
                 } else if (i < 3) {
                     // RGB color values to 0..1
-                    value /= 255;
+                    value /= /%$/.test(component) ? 100 : 255;
                 }
                 components[i] = value;
             }
diff --git a/test/tests/Color.js b/test/tests/Color.js
index 363cdcc8..bf572e29 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -84,6 +84,9 @@ test('Creating Colors', function() {
     equals(new Color('rgba( 255, 0, 0, 0.5 )'), new Color(1, 0, 0, 0.5),
             'Color from rgba() string 2nd test');
 
+    equals(new Color('rgb(100%, 50%, 0%)'), new Color(1, 0.5, 0),
+            'Color from rgb() percenst string');
+
     equals(new Color('hsl(180deg, 20%, 40%)'),
             new Color({ hue: 180, saturation: 0.2, lightness: 0.4 }),
             'Color from hsl() string');

From 1f39b1df98c615cea773a09c7e165b6c2f193cb2 Mon Sep 17 00:00:00 2001
From: waruyama <43434568+waruyama@users.noreply.github.com>
Date: Fri, 13 Dec 2019 14:32:31 +0100
Subject: [PATCH 141/181] First implementation of sweep and prune (#1740)

---
 src/paper.js                   |   1 +
 src/path/Curve.js              |  73 +++++----
 src/path/PathItem.Boolean.js   | 124 ++++++++++----
 src/path/PathItem.js           |  16 +-
 src/util/CollisionDetection.js | 292 +++++++++++++++++++++++++++++++++
 5 files changed, 436 insertions(+), 70 deletions(-)
 create mode 100644 src/util/CollisionDetection.js

diff --git a/src/paper.js b/src/paper.js
index fc00e683..de0350eb 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -42,6 +42,7 @@ var paper = function(self, undefined) {
 /*#*/ include('core/PaperScope.js');
 /*#*/ include('core/PaperScopeItem.js');
 
+/*#*/ include('util/CollisionDetection.js');
 /*#*/ include('util/Formatter.js');
 /*#*/ include('util/Numerical.js');
 /*#*/ include('util/UID.js');
diff --git a/src/path/Curve.js b/src/path/Curve.js
index ac23371b..5cabea60 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2103,52 +2103,55 @@ new function() { // Scope for bezier intersection using fat-line clipping
     }
 
     function getIntersections(curves1, curves2, include, matrix1, matrix2,
-            _returnFirst) {
+        _returnFirst) {
+        var epsilon = Numerical.GEOMETRIC_EPSILON;
         var self = !curves2;
         if (self)
             curves2 = curves1;
         var length1 = curves1.length,
             length2 = curves2.length,
-            values2 = [],
-            arrays = [],
-            locations,
-            current;
-        // Cache values for curves2 as we re-iterate them for each in curves1.
-        for (var i = 0; i < length2; i++)
-            values2[i] = curves2[i].getValues(matrix2);
+            values1 = new Array(length1),
+            values2 = self ? values1 : new Array(length2),
+            locations = [];
+
         for (var i = 0; i < length1; i++) {
-            var curve1 = curves1[i],
-                values1 = self ? values2[i] : curve1.getValues(matrix1),
-                path1 = curve1.getPath();
-            // NOTE: Due to the nature of getCurveIntersections(), we use
-            // separate location arrays per path1, to make sure the circularity
-            // checks are not getting confused by locations on separate paths.
-            // The separate arrays are then flattened in the end.
-            if (path1 !== current) {
-                current = path1;
-                locations = [];
-                arrays.push(locations);
+            var v = curves1[i].getValues(matrix1);
+            values1[i] = v;
+        }
+        if (!self) {
+            for (var i = 0; i < length2; i++) {
+                var v = curves2[i].getValues(matrix2);
+                values2[i] = v;
             }
+        }
+        var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+            values1, self ? null : values2, epsilon);
+        for (var index1 = 0; index1 < length1; index1++) {
+            var curve1 = curves1[index1],
+                v1 = values1[index1];
             if (self) {
                 // First check for self-intersections within the same curve.
-                getSelfIntersection(values1, curve1, locations, include);
+                getSelfIntersection(v1, curve1, locations, include);    
             }
-            // Check for intersections with other curves.
-            // For self-intersection, we can start at i + 1 instead of 0.
-            for (var j = self ? i + 1 : 0; j < length2; j++) {
-                // There might be already one location from the above
-                // self-intersection check:
-                if (_returnFirst && locations.length)
-                    return locations;
-                getCurveIntersections(values1, values2[j], curve1, curves2[j],
-                        locations, include);
+            // Check for intersections with potentially intersecting curves.
+            var collisions1 = boundsCollisions[index1];
+            if (collisions1) {
+                for (var j = 0; j < collisions1.length; j++) {
+                    // There might be already one location from the above
+                    // self-intersection check:
+                    if (_returnFirst && locations.length)
+                        return locations;
+                    var index2 = collisions1[j];
+                    if (!self || index2 > index1) {
+                        var curve2 = curves2[index2],
+                            v2 = values2[index2];
+                        getCurveIntersections(
+                            v1, v2, curve1, curve2, locations, include
+                        );
+                    }
+                }
             }
-        }
-        // Flatten the list of location arrays to one array and return it.
-        locations = [];
-        for (var i = 0, l = arrays.length; i < l; i++) {
-            Base.push(locations, arrays[i]);
-        }
+        }  
         return locations;
     }
 
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index a38aac3d..b97dbb29 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -156,19 +156,61 @@ PathItem.inject(new function() {
             collect(paths1);
             if (paths2)
                 collect(paths2);
+
+            var curvesValues = new Array(curves.length);
+            for (var i = 0, l = curves.length; i < l; i++) {
+                curvesValues[i] = curves[i].getValues();
+            }
+            var horCurveCollisions = 
+                CollisionDetection.findCurveBoundsCollisions(
+                    curvesValues, curvesValues, 0, false, true);
+            var horCurvesMap = {};
+            for (var i = 0; i < curves.length; i++) {
+                var curve = curves[i],
+                    collidingCurves = [],
+                    collisionIndices = horCurveCollisions[i];
+                if (collisionIndices) {
+                    for (var j = 0; j < collisionIndices.length; j++) {
+                        collidingCurves.push(curves[collisionIndices[j]]);
+                    }
+                }
+                var pathId = curve.getPath().getId();
+                horCurvesMap[pathId] = horCurvesMap[pathId] || {};
+                horCurvesMap[pathId][curve.getIndex()] = collidingCurves;
+            }
+
+            var vertCurveCollisions = 
+                CollisionDetection.findCurveBoundsCollisions(
+                    curvesValues, curvesValues, 0, true, true);
+            var vertCurvesMap = {};
+            for (var i = 0; i < curves.length; i++) {
+                var curve = curves[i],
+                    collidingCurves = [],
+                    collisionIndices = vertCurveCollisions[i];
+                if (collisionIndices) {
+                    for (var j = 0; j < collisionIndices.length; j++) {
+                        collidingCurves.push(curves[collisionIndices[j]]);
+                    }
+                }
+                var pathId = curve.getPath().getId();
+                vertCurvesMap[pathId] = vertCurvesMap[pathId] || {};
+                vertCurvesMap[pathId][curve.getIndex()] = collidingCurves;
+            }
+
             // Propagate the winding contribution. Winding contribution of
             // curves does not change between two crossings.
             // First, propagate winding contributions for curve chains starting
             // in all crossings:
             for (var i = 0, l = crossings.length; i < l; i++) {
-                propagateWinding(crossings[i]._segment, _path1, _path2, curves,
-                        operator);
+                propagateWinding(crossings[i]._segment, _path1, _path2, 
+                    horCurvesMap, vertCurvesMap, operator);
             }
             for (var i = 0, l = segments.length; i < l; i++) {
                 var segment = segments[i],
                     inter = segment._intersection;
                 if (!segment._winding) {
-                    propagateWinding(segment, _path1, _path2, curves, operator);
+                    propagateWinding(segment, _path1, _path2, 
+                        horCurvesMap, vertCurvesMap, operator);
                 }
                 // See if all encountered segments in a path are overlaps.
                 if (!(inter && inter._overlap))
@@ -186,7 +228,6 @@ PathItem.inject(new function() {
                         return !!operator[w];
                     });
         }
-
         return createResult(paths, true, path1, path2, options);
     }
 
@@ -300,29 +341,39 @@ PathItem.inject(new function() {
                 // Get reference to the first, largest path and insert it
                 // already.
                 first = sorted[0];
+            // create lookup containing potentially overlapping path bounds
+            var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+                    null, Numerical.GEOMETRIC_EPSILON);
             if (clockwise == null)
                 clockwise = first.isClockwise();
             // Now determine the winding for each path, from large to small.
             for (var i = 0; i < length; i++) {
                 var path1 = sorted[i],
-                    entry1 = lookup[path1._id],
-                    point = path1.getInteriorPoint(),
-                    containerWinding = 0;
-                for (var j = i - 1; j >= 0; j--) {
-                    var path2 = sorted[j];
-                    // As we run through the paths from largest to smallest, for
-                    // any current path, all potentially containing paths have
-                    // already been processed and their orientation fixed.
-                    // To achieve correct orientation of contained paths based
-                    // on winding, we have to find one containing path with
-                    // different "insideness" and set opposite orientation.
-                    if (path2.contains(point)) {
-                        var entry2 = lookup[path2._id];
-                        containerWinding = entry2.winding;
-                        entry1.winding += containerWinding;
-                        entry1.container = entry2.exclude ? entry2.container
-                                : path2;
-                        break;
+                    indicesI = collisions[i];
+                if (indicesI) {
+                    var entry1 = lookup[path1._id],
+                        point = null; // interior point, only get it if required
+                        containerWinding = 0;
+                    for (var j = indicesI.length - 1; j >= 0; j--) {
+                        if (indicesI[j] < i) {
+                            point = point || path1.getInteriorPoint();
+                            var path2 = sorted[indicesI[j]];
+                            // As we run through the paths from largest to 
+                            // smallest, for any current path, all potentially
+                            // containing paths have already been processed and
+                            // their orientation fixed. To achieve correct
+                            // orientation of contained paths based on winding,
+                            // we have to find one containing path with
+                            // different "insideness" and set opposite orientation.
+                            if (path2.contains(point)) {
+                                var entry2 = lookup[path2._id];
+                                containerWinding = entry2.winding;
+                                entry1.winding += containerWinding;
+                                entry1.container = entry2.exclude ? 
+                                        entry2.container : path2;
+                                break;
+                            }
+                        }
                     }
                 }
                 // Only keep paths if the "insideness" changes when crossing the
@@ -483,9 +534,16 @@ PathItem.inject(new function() {
      *
      * @param {Point} point the location for which to determine the winding
      *     contribution
-     * @param {Curve[]} curves the curves that describe the shape against which
+     * @param {Curve[]} curvesH The curves that describe the shape against which
      *     to check, as returned by {@link Path#curves} or
-     *     {@link CompoundPath#curves}
+     *     {@link CompoundPath#curves}. This only has to contain those curves
+     *     that can be crossed by a horizontal line through the point to be
+     *     checked.
+     * @param {Curve[]} curvesV  The curves that describe the shape against which
+     *     to check, as returned by {@link Path#curves} or
+     *     {@link CompoundPath#curves}. This only has to contain those curves
+     *     that can be crossed by a vertical line through the point to be
+     *     checked.
      * @param {Boolean} [dir=false] the direction in which to determine the
      *     winding contribution, `false`: in x-direction, `true`: in y-direction
      * @param {Boolean} [closed=false] determines how areas should be closed
@@ -498,7 +556,8 @@ PathItem.inject(new function() {
      *     well as an indication whether the point was situated on the contour
      * @private
      */
-    function getWinding(point, curves, dir, closed, dontFlip) {
+    function getWinding(point, curvesH, curvesV, dir, closed, dontFlip) {
+        var curves = !dir ? curvesV : curvesH;
         // Determine the index of the abscissa and ordinate values in the curve
         // values arrays, based on the direction:
         var ia = dir ? 1 : 0, // the abscissa index
@@ -613,7 +672,7 @@ PathItem.inject(new function() {
             // again with flipped direction and return that result instead.
             return !dontFlip && a > paL && a < paR
                     && Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-                    && getWinding(point, curves, !dir, closed, true);
+                    && getWinding(point, curvesH, curvesV, !dir, closed, true);
         }
 
         function handleCurve(v) {
@@ -734,7 +793,8 @@ PathItem.inject(new function() {
         };
     }
 
-    function propagateWinding(segment, path1, path2, curves, operator) {
+    function propagateWinding(segment, path1, path2, horCurveCollisionsMap,
+        vertCurveCollisionsMap, operator) {
         // Here we try to determine the most likely winding number contribution
         // for the curve-chain starting with this segment. Once we have enough
         // confidence in the winding contribution, we can propagate it until the
@@ -801,7 +861,12 @@ PathItem.inject(new function() {
                             }
                         }
                     }
-                    wind = wind || getWinding(pt, curves, dir, true);
+                    var pathId = path.getId();
+                    var curveIndex = curve.getIndex();
+                    var hCollisions = horCurveCollisionsMap[pathId][curveIndex];
+                    var vCollisions = vertCurveCollisionsMap[pathId][curveIndex];
+                    wind = wind || 
+                           getWinding(pt, hCollisions, vCollisions, dir, true);
                     if (wind.quality > winding.quality)
                         winding = wind;
                     break;
@@ -1077,7 +1142,8 @@ PathItem.inject(new function() {
          * @return {Number} the winding number
          */
         _getWinding: function(point, dir, closed) {
-            return getWinding(point, this.getCurves(), dir, closed);
+          let curves = this.getCurves();
+            return getWinding(point, curves, curves, dir, closed);
         },
 
         /**
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index 01000361..03115233 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -722,16 +722,20 @@ var PathItem = Item.extend(/** @lends PathItem# */{
                 matched = [],
                 count = 0;
             ok = true;
+            var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);      
             for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
                 var path1 = paths1[i1];
                 ok = false;
-                for (var i2 = length2 - 1; i2 >= 0 && !ok; i2--) {
-                    if (path1.compare(paths2[i2])) {
-                        if (!matched[i2]) {
-                            matched[i2] = true;
-                            count++;
+                var pathBoundsOverlaps = boundsOverlaps[i1];
+                if (pathBoundsOverlaps) {
+                    for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+                        if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+                            if (!matched[pathBoundsOverlaps[i2]]) {
+                                matched[pathBoundsOverlaps[i2]] = true;
+                                count++;
+                            }
+                            ok = true;
                         }
-                        ok = true;
                     }
                 }
             }
diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
new file mode 100644
index 00000000..37e26ea6
--- /dev/null
+++ b/src/util/CollisionDetection.js
@@ -0,0 +1,292 @@
+/*
+ * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ */
+
+/**
+ * @name CollisionDetection
+ * @namespace
+ * @private
+ */
+var CollisionDetection =  /** @lends CollisionDetection */{
+
+    /**
+     * Finds collisions between axis aligned bounding boxes of items.
+     * 
+     * This function takes the bounds of all items in the items1 and items2
+     * arrays and calls findBoundsCollisions().
+     *
+     * @param {Array} itemsA Array of curve values for which collisions should
+     *     be found. 
+     * @param {Array} [itemsA] Array of curve values that the first array should
+     *     be compared with. If not provided, collisions between items within
+     *     the first arrray will be returned.
+     * @param {Number} [tolerance] If provided, the tolerance will be added to
+     *     all sides of each bounds when checking for collisions.
+     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
+     *     along the y axis.
+     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
+     *     checks will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at thes same index in
+     *      itemsA an array of the indexes of colliding bounds in itemsB
+     *
+     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
+     */
+    findItemBoundsCollisions: function(itemsA, itemsB, tolerance,
+        sweepVertical, onlySweepAxisCollisions) {
+        var boundsArr1 = new Array(itemsA.length),
+            boundsArr2;
+        for (var i = 0; i < boundsArr1.length; i++) {
+            var bounds = itemsA[i].bounds;
+            boundsArr1[i] = [bounds.left, bounds.top, bounds.right,
+                bounds.bottom];
+        }
+        if (itemsB) {
+            if (itemsB === itemsA) {
+                boundsArr2 = boundsArr1;
+            } else {
+                boundsArr2 = new Array(itemsB.length);
+                for (var i = 0; i < boundsArr2.length; i++) {
+                    var bounds = itemsB[i].bounds;
+                    boundsArr2[i] = [bounds.left, bounds.top, bounds.right,
+                        bounds.bottom];
+                }
+            }
+        }
+        return this.findBoundsCollisions(boundsArr1, boundsArr2, tolerance || 0,
+            sweepVertical, onlySweepAxisCollisions);
+    },
+
+    /**
+     * Finds collisions between curves bounds. For performance reasons this
+     * uses broad bounds of the curve, which can be calculated much faster than
+     * the actual bounds. Broad bounds guarantee to contain the full curve,
+     * but they are usually larger than the actual bounds of a curve.
+     *
+     * This function takes the broad bounds of all curve values in the
+     * curveValues1 and curveValues2 arrays and calls findBoundsCollisions().
+     *
+     * @param {Array} curvesValues1 Array of curve values for which collisions
+     *     should be found. 
+     * @param {Array} [curvesValues2] Array of curve values that the first
+     *     array should be compared with. If not provided, collisions between
+     *     curve bounds within the first arrray will be returned.
+     * @param {Number} [tolerance] If provided, the tolerance will be added to
+     *     all sides of each bounds when checking for collisions.
+     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
+     *     along the y axis.
+     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
+     *     checks will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at thes same index in
+     *      curveValuesA an array of the indexes of colliding bounds in
+     *      curveValuesB
+     *
+     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
+     */
+    findCurveBoundsCollisions: function(curvesValues1, curvesValues2,
+        tolerance, sweepVertical, onlySweepAxisCollisions) {
+        var min = Math.min,
+            max = Math.max,
+            boundsArr1 = new Array(curvesValues1.length),
+            boundsArr2;
+        for (var i = 0; i < boundsArr1.length; i++) {
+            var v1 = curvesValues1[i];
+            boundsArr1[i] = [
+                min(v1[0], v1[2], v1[4], v1[6]),
+                min(v1[1], v1[3], v1[5], v1[7]),
+                max(v1[0], v1[2], v1[4], v1[6]),
+                max(v1[1], v1[3], v1[5], v1[7])
+            ];
+        }
+        if (curvesValues2) {
+            if (curvesValues2 === curvesValues1) {
+                boundsArr2 = boundsArr1;
+            } else {
+                boundsArr2 = new Array(curvesValues2.length);
+                for (var i = 0; i < boundsArr2.length; i++) {
+                    var v2 = curvesValues2[i];
+                    boundsArr2[i] = [
+                        min(v2[0], v2[2], v2[4], v2[6]),
+                        min(v2[1], v2[3], v2[5], v2[7]),
+                        max(v2[0], v2[2], v2[4], v2[6]),
+                        max(v2[1], v2[3], v2[5], v2[7])
+                    ];
+                }
+            }
+        }
+        return this.findBoundsCollisions(boundsArr1, boundsArr2,
+            tolerance || 0, sweepVertical, onlySweepAxisCollisions);
+    },
+
+    /**
+     * Finds collisions between two sets of bounding rectangles.
+     * 
+     * The collision detection is implemented as a sweep and prune algorithm
+     * with sweep either along the x or y axis (primary axis) and immediate
+     * check on secondary axis for potential pairs.
+     * 
+     * Each entry in the bounds arrays must be an array of length 4 with 
+     * x0, y0, x1, and y1 as the array elements.
+     * 
+     * The returned array has the same length as boundsArr1. Each entry
+     * contains an array with all indices of overlapping bounds of 
+     * boundsArr2 (or boundsArr1 if boundsArr2 is not provided) sorted
+     * in ascending order.
+     * 
+     * If the second bounds array parameter is null, collisions between bounds
+     * within the first bounds array will be found. In this case the indexed
+     * returned for each bounds will not contain the bounds' own index.
+     *
+     *
+     * @param {Array} boundsArr1 Array of bounds objects for which collisions
+     *     should be found. 
+     * @param {Array} [boundsArr2] Array of bounds that the first array should
+     *     be compared with. If not provided, collisions between bounds within
+     *     the first arrray will be returned.
+     * @param {Number} [tolerance] If provided, the tolerance will be added to
+     *     all sides of each bounds when checking for collisions.
+     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
+     *     along the y axis.
+     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
+     *     checks will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at thes same index in
+     *      boundsA an array of the indexes of colliding bounds in boundsB
+     *
+     * @author Jan Boesenberg <jan.boesenberg@gmail.com>    
+     */
+    findBoundsCollisions: function(boundsA, boundsB, tolerance,
+        sweepVertical, onlySweepAxisCollisions) {
+        // Binary search utility function.
+        // For multiple same entries, this returns the rightmost entry.
+        // https://en.wikipedia.org/wiki/Binary_search_algorithm#Procedure_for_finding_the_rightmost_element
+        var lo, hi;
+        var binarySearch = function(indices, coordinateValue, coordinate) {
+            lo = 0;
+            hi = indices.length;
+            while (lo < hi) {
+                var mid = (hi + lo) >>> 1; // same as Math.floor((hi+lo)/2)
+                if (allBounds[indices[mid]][coordinate] < coordinateValue) {
+                    lo = mid + 1;
+                } else {
+                    hi = mid;
+                }
+            }
+            return lo - 1;
+        };
+
+        //
+        var self = !boundsB || boundsA === boundsB,
+            allBounds = self ? boundsA : boundsA.concat(boundsB),
+            countA = boundsA.length,
+            countAll = allBounds.length;
+        // Set coordinates for primary and secondary axis depending on sweep
+        // direction. By default we sweep in horizontal direction, which
+        // means x is the primary axis.
+        var coordP0 = sweepVertical ? 1 : 0,
+            coordP1 = coordP0 + 2,
+            coordS0 = sweepVertical ? 0 : 1,
+            coordS1 = coordS0 + 2;
+        // Create array with all indices sorted by lower boundary on primary
+        // axis.
+        var allIndicesByP0 = new Array(countAll);
+        for (var i = 0; i < countAll; i++) {
+            allIndicesByP0[i] = i;
+        }
+        allIndicesByP0.sort(function(i1, i2) {
+            return allBounds[i1][coordP0] - allBounds[i2][coordP0];
+        });
+        // Sweep along primary axis. Indices of active bounds are kept in an
+        // array sorted by higher boundary on primary axis.
+        var activeIndicesByP1 = [],
+            allCollisions = new Array(countA);
+        for (var i = 0; i < countAll; i++) {
+            var currentIndex = allIndicesByP0[i],
+                currentBounds = allBounds[currentIndex];
+                currentOriginalIndex = self ? currentIndex
+                    : currentIndex - countA, // index in boundsA or boundsB array
+                isCurrentA = currentIndex < countA,
+                isCurrentB = self || currentIndex >= countA,
+                currentCollisions = isCurrentA ? [] : null;
+            if (activeIndicesByP1.length) {
+                // remove (prune) indices that are no longer active
+                var pruneCount = binarySearch(activeIndicesByP1,
+                        currentBounds[coordP0] - tolerance, coordP1) + 1;
+                activeIndicesByP1.splice(0, pruneCount);
+                // add collisions for current index
+                if (self && onlySweepAxisCollisions) {
+                    // All active indexes can be added, no further checks needed
+                    currentCollisions = currentCollisions.concat(
+                        activeIndicesByP1.slice());
+                   // Add current index to collisions of all active indexes
+                    for (var j = 0; j < activeIndicesByP1.length; j++) {
+                        var activeIndex = activeIndicesByP1[j];
+                        allCollisions[activeIndex].push(currentOriginalIndex);
+                    }
+                } else {
+                    var currentS1 = currentBounds[coordS1],
+                        currentS0 = currentBounds[coordS0];
+                    for (var j = 0; j < activeIndicesByP1.length; j++) {
+                        var activeIndex = activeIndicesByP1[j],
+                            isActiveA = activeIndex < countA,
+                            isActiveB = self || activeIndex >= countA;
+                        // Check secondary axis bounds if necessary
+                        if (onlySweepAxisCollisions ||
+                            (((isCurrentA && isActiveB) ||
+                                (isCurrentB && isActiveA)) &&
+                                currentS1 >=
+                                    allBounds[activeIndex][coordS0] -
+                                        tolerance &&
+                                    currentS0 <=
+                                        allBounds[activeIndex][coordS1] +
+                                            tolerance)) {
+                            // Add current index to collisions of active
+                            // indices and vice versa.
+                            if (isCurrentA && isActiveB) {
+                                currentCollisions.push(
+                                    self ? activeIndex : activeIndex - countA);
+                            }
+                            if (isCurrentB && isActiveA) {
+                                allCollisions[activeIndex].push(
+                                    currentOriginalIndex);
+                            }
+                        }
+                    }
+                }
+            }
+            if (isCurrentA) {
+                if (boundsA === boundsB) {
+                    // if both arrays are the same, add self collision
+                    currentCollisions.push(currentIndex);
+                }
+                // add collisions for current index
+                allCollisions[currentIndex] = currentCollisions;
+            }
+            // add current index to active indices. Keep array sorted by
+            // their higher boundary on the primary axis
+            if (activeIndicesByP1.length) {
+                var currentP1 = currentBounds[coordP1],
+                    insertIndex =
+                    binarySearch(activeIndicesByP1, currentP1, coordP1) + 1;
+                activeIndicesByP1.splice(insertIndex, 0, currentIndex);
+            } else {
+                activeIndicesByP1.push(currentIndex);
+            }
+        }
+        // Sort collision indioes in ascending order
+        for (var i = 0; i < allCollisions.length; i++) {
+            if (allCollisions[i]) {
+                allCollisions[i].sort(function(i1, i2) {
+                    return i1 - i2;
+                });
+            }
+        }
+        return allCollisions;
+    }
+};
\ No newline at end of file

From a183dc0c0d7ba05d9ac0f60bcf1b3ff9b1e2a745 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 13 Dec 2019 16:13:56 +0100
Subject: [PATCH 142/181] Fix various issues introduced in #1740

---
 src/path/PathItem.Boolean.js   | 24 +++++++++----------
 src/util/CollisionDetection.js | 44 +++++++++++++++++-----------------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index b97dbb29..a45c44e1 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -161,7 +161,7 @@ PathItem.inject(new function() {
             for (var i = 0, l = curves.length; i < l; i++) {
                 curvesValues[i] = curves[i].getValues();
             }
-            var horCurveCollisions = 
+            var horCurveCollisions =
                 CollisionDetection.findCurveBoundsCollisions(
                     curvesValues, curvesValues, 0, false, true);
             var horCurvesMap = {};
@@ -179,7 +179,7 @@ PathItem.inject(new function() {
                 horCurvesMap[pathId][curve.getIndex()] = collidingCurves;
             }
 
-            var vertCurveCollisions = 
+            var vertCurveCollisions =
                 CollisionDetection.findCurveBoundsCollisions(
                     curvesValues, curvesValues, 0, true, true);
             var vertCurvesMap = {};
@@ -202,14 +202,14 @@ PathItem.inject(new function() {
             // First, propagate winding contributions for curve chains starting
             // in all crossings:
             for (var i = 0, l = crossings.length; i < l; i++) {
-                propagateWinding(crossings[i]._segment, _path1, _path2, 
+                propagateWinding(crossings[i]._segment, _path1, _path2,
                     horCurvesMap, vertCurvesMap, operator);
             }
             for (var i = 0, l = segments.length; i < l; i++) {
                 var segment = segments[i],
                     inter = segment._intersection;
                 if (!segment._winding) {
-                    propagateWinding(segment, _path1, _path2, 
+                    propagateWinding(segment, _path1, _path2,
                         horCurvesMap, vertCurvesMap, operator);
                 }
                 // See if all encountered segments in a path are overlaps.
@@ -349,16 +349,16 @@ PathItem.inject(new function() {
             // Now determine the winding for each path, from large to small.
             for (var i = 0; i < length; i++) {
                 var path1 = sorted[i],
-                    indicesI = collisions[i];
+                    indicesI = collisions[i],
+                    entry1 = lookup[path1._id],
+                    containerWinding = 0;
                 if (indicesI) {
-                    var entry1 = lookup[path1._id],
-                        point = null; // interior point, only get it if required
-                        containerWinding = 0;
+                    var point = null; // interior point, only get it if required
                     for (var j = indicesI.length - 1; j >= 0; j--) {
                         if (indicesI[j] < i) {
                             point = point || path1.getInteriorPoint();
                             var path2 = sorted[indicesI[j]];
-                            // As we run through the paths from largest to 
+                            // As we run through the paths from largest to
                             // smallest, for any current path, all potentially
                             // containing paths have already been processed and
                             // their orientation fixed. To achieve correct
@@ -369,7 +369,7 @@ PathItem.inject(new function() {
                                 var entry2 = lookup[path2._id];
                                 containerWinding = entry2.winding;
                                 entry1.winding += containerWinding;
-                                entry1.container = entry2.exclude ? 
+                                entry1.container = entry2.exclude ?
                                         entry2.container : path2;
                                 break;
                             }
@@ -865,7 +865,7 @@ PathItem.inject(new function() {
                     var curveIndex = curve.getIndex();
                     var hCollisions = horCurveCollisionsMap[pathId][curveIndex];
                     var vCollisions = vertCurveCollisionsMap[pathId][curveIndex];
-                    wind = wind || 
+                    wind = wind ||
                            getWinding(pt, hCollisions, vCollisions, dir, true);
                     if (wind.quality > winding.quality)
                         winding = wind;
@@ -1142,7 +1142,7 @@ PathItem.inject(new function() {
          * @return {Number} the winding number
          */
         _getWinding: function(point, dir, closed) {
-          let curves = this.getCurves();
+            var curves = this.getCurves();
             return getWinding(point, curves, curves, dir, closed);
         },
 
diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
index 37e26ea6..24160a30 100644
--- a/src/util/CollisionDetection.js
+++ b/src/util/CollisionDetection.js
@@ -19,12 +19,12 @@ var CollisionDetection =  /** @lends CollisionDetection */{
 
     /**
      * Finds collisions between axis aligned bounding boxes of items.
-     * 
+     *
      * This function takes the bounds of all items in the items1 and items2
      * arrays and calls findBoundsCollisions().
      *
      * @param {Array} itemsA Array of curve values for which collisions should
-     *     be found. 
+     *     be found.
      * @param {Array} [itemsA] Array of curve values that the first array should
      *     be compared with. If not provided, collisions between items within
      *     the first arrray will be returned.
@@ -74,7 +74,7 @@ var CollisionDetection =  /** @lends CollisionDetection */{
      * curveValues1 and curveValues2 arrays and calls findBoundsCollisions().
      *
      * @param {Array} curvesValues1 Array of curve values for which collisions
-     *     should be found. 
+     *     should be found.
      * @param {Array} [curvesValues2] Array of curve values that the first
      *     array should be compared with. If not provided, collisions between
      *     curve bounds within the first arrray will be returned.
@@ -127,26 +127,26 @@ var CollisionDetection =  /** @lends CollisionDetection */{
 
     /**
      * Finds collisions between two sets of bounding rectangles.
-     * 
+     *
      * The collision detection is implemented as a sweep and prune algorithm
      * with sweep either along the x or y axis (primary axis) and immediate
      * check on secondary axis for potential pairs.
-     * 
-     * Each entry in the bounds arrays must be an array of length 4 with 
+     *
+     * Each entry in the bounds arrays must be an array of length 4 with
      * x0, y0, x1, and y1 as the array elements.
-     * 
+     *
      * The returned array has the same length as boundsArr1. Each entry
-     * contains an array with all indices of overlapping bounds of 
+     * contains an array with all indices of overlapping bounds of
      * boundsArr2 (or boundsArr1 if boundsArr2 is not provided) sorted
      * in ascending order.
-     * 
+     *
      * If the second bounds array parameter is null, collisions between bounds
      * within the first bounds array will be found. In this case the indexed
      * returned for each bounds will not contain the bounds' own index.
      *
      *
      * @param {Array} boundsArr1 Array of bounds objects for which collisions
-     *     should be found. 
+     *     should be found.
      * @param {Array} [boundsArr2] Array of bounds that the first array should
      *     be compared with. If not provided, collisions between bounds within
      *     the first arrray will be returned.
@@ -159,15 +159,20 @@ var CollisionDetection =  /** @lends CollisionDetection */{
      * @returns {Array} Array containing for the bounds at thes same index in
      *      boundsA an array of the indexes of colliding bounds in boundsB
      *
-     * @author Jan Boesenberg <jan.boesenberg@gmail.com>    
+     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
      */
     findBoundsCollisions: function(boundsA, boundsB, tolerance,
         sweepVertical, onlySweepAxisCollisions) {
         // Binary search utility function.
         // For multiple same entries, this returns the rightmost entry.
         // https://en.wikipedia.org/wiki/Binary_search_algorithm#Procedure_for_finding_the_rightmost_element
-        var lo, hi;
-        var binarySearch = function(indices, coordinateValue, coordinate) {
+        var self = !boundsB || boundsA === boundsB,
+            allBounds = self ? boundsA : boundsA.concat(boundsB),
+            countA = boundsA.length,
+            countAll = allBounds.length,
+            lo, hi;
+
+        function binarySearch(indices, coordinateValue, coordinate) {
             lo = 0;
             hi = indices.length;
             while (lo < hi) {
@@ -179,13 +184,8 @@ var CollisionDetection =  /** @lends CollisionDetection */{
                 }
             }
             return lo - 1;
-        };
+        }
 
-        //
-        var self = !boundsB || boundsA === boundsB,
-            allBounds = self ? boundsA : boundsA.concat(boundsB),
-            countA = boundsA.length,
-            countAll = allBounds.length;
         // Set coordinates for primary and secondary axis depending on sweep
         // direction. By default we sweep in horizontal direction, which
         // means x is the primary axis.
@@ -208,7 +208,7 @@ var CollisionDetection =  /** @lends CollisionDetection */{
             allCollisions = new Array(countA);
         for (var i = 0; i < countAll; i++) {
             var currentIndex = allIndicesByP0[i],
-                currentBounds = allBounds[currentIndex];
+                currentBounds = allBounds[currentIndex],
                 currentOriginalIndex = self ? currentIndex
                     : currentIndex - countA, // index in boundsA or boundsB array
                 isCurrentA = currentIndex < countA,
@@ -279,7 +279,7 @@ var CollisionDetection =  /** @lends CollisionDetection */{
                 activeIndicesByP1.push(currentIndex);
             }
         }
-        // Sort collision indioes in ascending order
+        // Sort collision indices in ascending order
         for (var i = 0; i < allCollisions.length; i++) {
             if (allCollisions[i]) {
                 allCollisions[i].sort(function(i1, i2) {
@@ -289,4 +289,4 @@ var CollisionDetection =  /** @lends CollisionDetection */{
         }
         return allCollisions;
     }
-};
\ No newline at end of file
+};

From 46f1aaeca17fd1ee479a7020d22245bdc13af7cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 13 Dec 2019 16:47:49 +0100
Subject: [PATCH 143/181] Some code refactoring for #1740

---
 src/path/Curve.js              |  21 +++---
 src/path/PathItem.Boolean.js   |  65 ++++++++--------
 src/util/CollisionDetection.js | 132 ++++++++++++++++-----------------
 3 files changed, 104 insertions(+), 114 deletions(-)

diff --git a/src/path/Curve.js b/src/path/Curve.js
index 5cabea60..258ca82f 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2103,9 +2103,9 @@ new function() { // Scope for bezier intersection using fat-line clipping
     }
 
     function getIntersections(curves1, curves2, include, matrix1, matrix2,
-        _returnFirst) {
-        var epsilon = Numerical.GEOMETRIC_EPSILON;
-        var self = !curves2;
+            _returnFirst) {
+        var epsilon = /*#=*/Numerical.GEOMETRIC_EPSILON,
+            self = !curves2;
         if (self)
             curves2 = curves1;
         var length1 = curves1.length,
@@ -2115,23 +2115,21 @@ new function() { // Scope for bezier intersection using fat-line clipping
             locations = [];
 
         for (var i = 0; i < length1; i++) {
-            var v = curves1[i].getValues(matrix1);
-            values1[i] = v;
+            values1[i] = curves1[i].getValues(matrix1);
         }
         if (!self) {
             for (var i = 0; i < length2; i++) {
-                var v = curves2[i].getValues(matrix2);
-                values2[i] = v;
+                values2[i] = curves2[i].getValues(matrix2);
             }
         }
         var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-            values1, self ? null : values2, epsilon);
+                values1, self ? null : values2, epsilon);
         for (var index1 = 0; index1 < length1; index1++) {
             var curve1 = curves1[index1],
                 v1 = values1[index1];
             if (self) {
                 // First check for self-intersections within the same curve.
-                getSelfIntersection(v1, curve1, locations, include);    
+                getSelfIntersection(v1, curve1, locations, include);
             }
             // Check for intersections with potentially intersecting curves.
             var collisions1 = boundsCollisions[index1];
@@ -2146,12 +2144,11 @@ new function() { // Scope for bezier intersection using fat-line clipping
                         var curve2 = curves2[index2],
                             v2 = values2[index2];
                         getCurveIntersections(
-                            v1, v2, curve1, curve2, locations, include
-                        );
+                                v1, v2, curve1, curve2, locations, include);
                     }
                 }
             }
-        }  
+        }
         return locations;
     }
 
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index a45c44e1..cfef7004 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -23,9 +23,8 @@
  *  - Boolean operations on self-intersecting Paths items
  *
  * @author Harikrishnan Gopalakrishnan <hari.exeption@gmail.com>
- * @author Jan Boesenberg <development@iconexperience.com>
+ * @author Jan Boesenberg <jan.boesenberg@gmail.com>
  * @author Juerg Lehni <juerg@scratchdisk.com>
- * https://hkrish.com/playground/paperjs/booleanStudy.html
  */
 PathItem.inject(new function() {
     var min = Math.min,
@@ -179,22 +178,22 @@ PathItem.inject(new function() {
                 horCurvesMap[pathId][curve.getIndex()] = collidingCurves;
             }
 
-            var vertCurveCollisions =
+            var verCurveCollisions =
                 CollisionDetection.findCurveBoundsCollisions(
                     curvesValues, curvesValues, 0, true, true);
-            var vertCurvesMap = {};
+            var verCurvesMap = {};
             for (var i = 0; i < curves.length; i++) {
                 var curve = curves[i],
                     collidingCurves = [],
-                    collisionIndices = vertCurveCollisions[i];
+                    collisionIndices = verCurveCollisions[i];
                 if (collisionIndices) {
                     for (var j = 0; j < collisionIndices.length; j++) {
                         collidingCurves.push(curves[collisionIndices[j]]);
                     }
                 }
                 var pathId = curve.getPath().getId();
-                vertCurvesMap[pathId] = vertCurvesMap[pathId] || {};
-                vertCurvesMap[pathId][curve.getIndex()] = collidingCurves;
+                verCurvesMap[pathId] = verCurvesMap[pathId] || {};
+                verCurvesMap[pathId][curve.getIndex()] = collidingCurves;
             }
 
             // Propagate the winding contribution. Winding contribution of
@@ -203,14 +202,14 @@ PathItem.inject(new function() {
             // in all crossings:
             for (var i = 0, l = crossings.length; i < l; i++) {
                 propagateWinding(crossings[i]._segment, _path1, _path2,
-                    horCurvesMap, vertCurvesMap, operator);
+                        horCurvesMap, verCurvesMap, operator);
             }
             for (var i = 0, l = segments.length; i < l; i++) {
                 var segment = segments[i],
                     inter = segment._intersection;
                 if (!segment._winding) {
                     propagateWinding(segment, _path1, _path2,
-                        horCurvesMap, vertCurvesMap, operator);
+                            horCurvesMap, verCurvesMap, operator);
                 }
                 // See if all encountered segments in a path are overlaps.
                 if (!(inter && inter._overlap))
@@ -349,28 +348,28 @@ PathItem.inject(new function() {
             // Now determine the winding for each path, from large to small.
             for (var i = 0; i < length; i++) {
                 var path1 = sorted[i],
-                    indicesI = collisions[i],
                     entry1 = lookup[path1._id],
-                    containerWinding = 0;
-                if (indicesI) {
-                    var point = null; // interior point, only get it if required
-                    for (var j = indicesI.length - 1; j >= 0; j--) {
-                        if (indicesI[j] < i) {
+                    containerWinding = 0,
+                    indices = collisions[i];
+                if (indices) {
+                    var point = null; // interior point, only get it if required.
+                    for (var j = indices.length - 1; j >= 0; j--) {
+                        if (indices[j] < i) {
                             point = point || path1.getInteriorPoint();
-                            var path2 = sorted[indicesI[j]];
+                            var path2 = sorted[indices[j]];
                             // As we run through the paths from largest to
                             // smallest, for any current path, all potentially
                             // containing paths have already been processed and
                             // their orientation fixed. To achieve correct
                             // orientation of contained paths based on winding,
-                            // we have to find one containing path with
-                            // different "insideness" and set opposite orientation.
+                            // find one containing path with different
+                            // "insideness" and set opposite orientation.
                             if (path2.contains(point)) {
                                 var entry2 = lookup[path2._id];
                                 containerWinding = entry2.winding;
                                 entry1.winding += containerWinding;
-                                entry1.container = entry2.exclude ?
-                                        entry2.container : path2;
+                                entry1.container = entry2.exclude
+                                    ? entry2.container : path2;
                                 break;
                             }
                         }
@@ -388,8 +387,8 @@ PathItem.inject(new function() {
                     // If the containing path is not excluded, we're done
                     // searching for the orientation defining path.
                     var container = entry1.container;
-                    path1.setClockwise(container ? !container.isClockwise()
-                            : clockwise);
+                    path1.setClockwise(
+                            container ? !container.isClockwise() : clockwise);
                 }
             }
         }
@@ -793,8 +792,8 @@ PathItem.inject(new function() {
         };
     }
 
-    function propagateWinding(segment, path1, path2, horCurveCollisionsMap,
-        vertCurveCollisionsMap, operator) {
+    function propagateWinding(segment, path1, path2, horCurvesMap, verCurvesMap,
+            operator) {
         // Here we try to determine the most likely winding number contribution
         // for the curve-chain starting with this segment. Once we have enough
         // confidence in the winding contribution, we can propagate it until the
@@ -845,9 +844,8 @@ PathItem.inject(new function() {
                     var wind = null;
                     if (operator.subtract && path2) {
                         // Calculate path winding at point depending on operand.
-                        var pathWinding = operand === path1
-                                          ? path2._getWinding(pt, dir, true)
-                                          : path1._getWinding(pt, dir, true);
+                        var otherPath = operand === path1 ? path2 : path1,
+                            pathWinding = otherPath._getWinding(pt, dir, true);
                         // Check if curve should be omitted.
                         if (operand === path1 && pathWinding.winding ||
                             operand === path2 && !pathWinding.winding) {
@@ -861,12 +859,13 @@ PathItem.inject(new function() {
                             }
                         }
                     }
-                    var pathId = path.getId();
-                    var curveIndex = curve.getIndex();
-                    var hCollisions = horCurveCollisionsMap[pathId][curveIndex];
-                    var vCollisions = vertCurveCollisionsMap[pathId][curveIndex];
-                    wind = wind ||
-                           getWinding(pt, hCollisions, vCollisions, dir, true);
+                    if (!wind) {
+                        var pathId = path.getId(),
+                            curveIndex = curve.getIndex(),
+                            curvesH = horCurvesMap[pathId][curveIndex],
+                            curvesV = verCurvesMap[pathId][curveIndex];
+                        wind = getWinding(pt, curvesH, curvesV, dir, true);
+                    }
                     if (wind.quality > winding.quality)
                         winding = wind;
                     break;
diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
index 24160a30..28cdb38a 100644
--- a/src/util/CollisionDetection.js
+++ b/src/util/CollisionDetection.js
@@ -14,54 +14,51 @@
  * @name CollisionDetection
  * @namespace
  * @private
+ * @author Jan Boesenberg <jan.boesenberg@gmail.com>
  */
-var CollisionDetection =  /** @lends CollisionDetection */{
-
+var CollisionDetection = /** @lends CollisionDetection */{
     /**
      * Finds collisions between axis aligned bounding boxes of items.
      *
      * This function takes the bounds of all items in the items1 and items2
      * arrays and calls findBoundsCollisions().
      *
-     * @param {Array} itemsA Array of curve values for which collisions should
-     *     be found.
-     * @param {Array} [itemsA] Array of curve values that the first array should
-     *     be compared with. If not provided, collisions between items within
-     *     the first arrray will be returned.
+     * @param {Array} items1 Array of items for which collisions should be
+     *     found.
+     * @param {Array} [items2] Array of items  that the first array should be
+     *     compared with. If not provided, collisions between items within
+     *     the first array will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
-     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
-     *     along the y axis.
-     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
-     *     checks will be done on the secondary axis.
-     * @returns {Array} Array containing for the bounds at thes same index in
-     *      itemsA an array of the indexes of colliding bounds in itemsB
-     *
-     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
+     * @param {Boolean} [sweepVertical] If true, the sweep is performed along
+     *     the y-axis.
+     * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
+     *     will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at the same index in
+     *     items1 an array of the indexes of colliding bounds in items2
      */
-    findItemBoundsCollisions: function(itemsA, itemsB, tolerance,
-        sweepVertical, onlySweepAxisCollisions) {
-        var boundsArr1 = new Array(itemsA.length),
-            boundsArr2;
-        for (var i = 0; i < boundsArr1.length; i++) {
-            var bounds = itemsA[i].bounds;
-            boundsArr1[i] = [bounds.left, bounds.top, bounds.right,
-                bounds.bottom];
+    findItemBoundsCollisions: function(items1, items2, tolerance,
+            sweepVertical, onlySweepAxisCollisions) {
+        var bounds1 = new Array(items1.length),
+            bounds2;
+        for (var i = 0; i < items1.length; i++) {
+            var bounds = items1[i].bounds;
+            bounds1[i] = [bounds.left, bounds.top, bounds.right, bounds.bottom];
         }
-        if (itemsB) {
-            if (itemsB === itemsA) {
-                boundsArr2 = boundsArr1;
+        if (items2) {
+            if (items2 === items1) {
+                bounds2 = bounds1;
             } else {
-                boundsArr2 = new Array(itemsB.length);
-                for (var i = 0; i < boundsArr2.length; i++) {
-                    var bounds = itemsB[i].bounds;
-                    boundsArr2[i] = [bounds.left, bounds.top, bounds.right,
+                bounds2 = new Array(items2.length);
+                for (var i = 0; i < items2.length; i++) {
+                    var bounds = items2[i].bounds;
+                    bounds2[i] = [bounds.left, bounds.top, bounds.right,
                         bounds.bottom];
                 }
             }
         }
-        return this.findBoundsCollisions(boundsArr1, boundsArr2, tolerance || 0,
-            sweepVertical, onlySweepAxisCollisions);
+        return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0,
+                sweepVertical, onlySweepAxisCollisions);
     },
 
     /**
@@ -80,25 +77,23 @@ var CollisionDetection =  /** @lends CollisionDetection */{
      *     curve bounds within the first arrray will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
-     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
-     *     along the y axis.
-     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
-     *     checks will be done on the secondary axis.
-     * @returns {Array} Array containing for the bounds at thes same index in
-     *      curveValuesA an array of the indexes of colliding bounds in
-     *      curveValuesB
-     *
-     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
+     * @param {Boolean} [sweepVertical] If true, the sweep is performed along
+     *     the y-axis.
+     * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
+     *     will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at the same index in
+     *     curveValues1 an array of the indexes of colliding bounds in
+     *     curveValues2
      */
     findCurveBoundsCollisions: function(curvesValues1, curvesValues2,
-        tolerance, sweepVertical, onlySweepAxisCollisions) {
+            tolerance, sweepVertical, onlySweepAxisCollisions) {
         var min = Math.min,
             max = Math.max,
-            boundsArr1 = new Array(curvesValues1.length),
-            boundsArr2;
-        for (var i = 0; i < boundsArr1.length; i++) {
+            bounds1 = new Array(curvesValues1.length),
+            bounds2;
+        for (var i = 0; i < bounds1.length; i++) {
             var v1 = curvesValues1[i];
-            boundsArr1[i] = [
+            bounds1[i] = [
                 min(v1[0], v1[2], v1[4], v1[6]),
                 min(v1[1], v1[3], v1[5], v1[7]),
                 max(v1[0], v1[2], v1[4], v1[6]),
@@ -107,12 +102,12 @@ var CollisionDetection =  /** @lends CollisionDetection */{
         }
         if (curvesValues2) {
             if (curvesValues2 === curvesValues1) {
-                boundsArr2 = boundsArr1;
+                bounds2 = bounds1;
             } else {
-                boundsArr2 = new Array(curvesValues2.length);
-                for (var i = 0; i < boundsArr2.length; i++) {
+                bounds2 = new Array(curvesValues2.length);
+                for (var i = 0; i < bounds2.length; i++) {
                     var v2 = curvesValues2[i];
-                    boundsArr2[i] = [
+                    bounds2[i] = [
                         min(v2[0], v2[2], v2[4], v2[6]),
                         min(v2[1], v2[3], v2[5], v2[7]),
                         max(v2[0], v2[2], v2[4], v2[6]),
@@ -121,8 +116,8 @@ var CollisionDetection =  /** @lends CollisionDetection */{
                 }
             }
         }
-        return this.findBoundsCollisions(boundsArr1, boundsArr2,
-            tolerance || 0, sweepVertical, onlySweepAxisCollisions);
+        return this.findBoundsCollisions(bounds1, bounds2,
+                tolerance || 0, sweepVertical, onlySweepAxisCollisions);
     },
 
     /**
@@ -135,9 +130,9 @@ var CollisionDetection =  /** @lends CollisionDetection */{
      * Each entry in the bounds arrays must be an array of length 4 with
      * x0, y0, x1, and y1 as the array elements.
      *
-     * The returned array has the same length as boundsArr1. Each entry
+     * The returned array has the same length as bounds1. Each entry
      * contains an array with all indices of overlapping bounds of
-     * boundsArr2 (or boundsArr1 if boundsArr2 is not provided) sorted
+     * bounds2 (or bounds1 if bounds2 is not provided) sorted
      * in ascending order.
      *
      * If the second bounds array parameter is null, collisions between bounds
@@ -145,21 +140,19 @@ var CollisionDetection =  /** @lends CollisionDetection */{
      * returned for each bounds will not contain the bounds' own index.
      *
      *
-     * @param {Array} boundsArr1 Array of bounds objects for which collisions
+     * @param {Array} boundsA Array of bounds objects for which collisions
      *     should be found.
-     * @param {Array} [boundsArr2] Array of bounds that the first array should
+     * @param {Array} [boundsB] Array of bounds that the first array should
      *     be compared with. If not provided, collisions between bounds within
      *     the first arrray will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
-     * @param {Boolean} [sweepVertical] If set to true, the sweep is done
-     *     along the y axis.
-     * @param {Boolean} [onlySweepAxisCollisionss] If set to true, no collision
-     *     checks will be done on the secondary axis.
-     * @returns {Array} Array containing for the bounds at thes same index in
-     *      boundsA an array of the indexes of colliding bounds in boundsB
-     *
-     * @author Jan Boesenberg <jan.boesenberg@gmail.com>
+     * @param {Boolean} [sweepVertical] If true, the sweep is performed along
+     *     the y-axis.
+     * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
+     *     will be done on the secondary axis.
+     * @returns {Array} Array containing for the bounds at the same index in
+     *     boundsA an array of the indexes of colliding bounds in boundsB
      */
     findBoundsCollisions: function(boundsA, boundsB, tolerance,
         sweepVertical, onlySweepAxisCollisions) {
@@ -176,7 +169,7 @@ var CollisionDetection =  /** @lends CollisionDetection */{
             lo = 0;
             hi = indices.length;
             while (lo < hi) {
-                var mid = (hi + lo) >>> 1; // same as Math.floor((hi+lo)/2)
+                var mid = (hi + lo) >>> 1; // Same as Math.floor((hi + lo) / 2)
                 if (allBounds[indices[mid]][coordinate] < coordinateValue) {
                     lo = mid + 1;
                 } else {
@@ -209,8 +202,9 @@ var CollisionDetection =  /** @lends CollisionDetection */{
         for (var i = 0; i < countAll; i++) {
             var currentIndex = allIndicesByP0[i],
                 currentBounds = allBounds[currentIndex],
-                currentOriginalIndex = self ? currentIndex
-                    : currentIndex - countA, // index in boundsA or boundsB array
+                currentOriginalIndex = self  // index in boundsA or boundsB
+                    ? currentIndex
+                    : currentIndex - countA,
                 isCurrentA = currentIndex < countA,
                 isCurrentB = self || currentIndex >= countA,
                 currentCollisions = isCurrentA ? [] : null;
@@ -273,13 +267,13 @@ var CollisionDetection =  /** @lends CollisionDetection */{
             if (activeIndicesByP1.length) {
                 var currentP1 = currentBounds[coordP1],
                     insertIndex =
-                    binarySearch(activeIndicesByP1, currentP1, coordP1) + 1;
+                        binarySearch(activeIndicesByP1, currentP1, coordP1) + 1;
                 activeIndicesByP1.splice(insertIndex, 0, currentIndex);
             } else {
                 activeIndicesByP1.push(currentIndex);
             }
         }
-        // Sort collision indices in ascending order
+        // Sort collision indices in ascending order.
         for (var i = 0; i < allCollisions.length; i++) {
             if (allCollisions[i]) {
                 allCollisions[i].sort(function(i1, i2) {

From d63647eb067ee13458bd8eed9a9756640018c3e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Fri, 13 Dec 2019 18:36:07 +0100
Subject: [PATCH 144/181] More refactoring for #1740

---
 src/util/CollisionDetection.js | 252 +++++++++++++++------------------
 1 file changed, 114 insertions(+), 138 deletions(-)

diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
index 28cdb38a..118af14b 100644
--- a/src/util/CollisionDetection.js
+++ b/src/util/CollisionDetection.js
@@ -30,35 +30,24 @@ var CollisionDetection = /** @lends CollisionDetection */{
      *     the first array will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
-     * @param {Boolean} [sweepVertical] If true, the sweep is performed along
-     *     the y-axis.
-     * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
-     *     will be done on the secondary axis.
      * @returns {Array} Array containing for the bounds at the same index in
      *     items1 an array of the indexes of colliding bounds in items2
      */
-    findItemBoundsCollisions: function(items1, items2, tolerance,
-            sweepVertical, onlySweepAxisCollisions) {
-        var bounds1 = new Array(items1.length),
-            bounds2;
-        for (var i = 0; i < items1.length; i++) {
-            var bounds = items1[i].bounds;
-            bounds1[i] = [bounds.left, bounds.top, bounds.right, bounds.bottom];
-        }
-        if (items2) {
-            if (items2 === items1) {
-                bounds2 = bounds1;
-            } else {
-                bounds2 = new Array(items2.length);
-                for (var i = 0; i < items2.length; i++) {
-                    var bounds = items2[i].bounds;
-                    bounds2[i] = [bounds.left, bounds.top, bounds.right,
-                        bounds.bottom];
-                }
+    findItemBoundsCollisions: function(items1, items2, tolerance) {
+        function getBounds(items) {
+            var bounds = new Array(items.length);
+            for (var i = 0; i < items.length; i++) {
+                var rect = items[i].getBounds();
+                bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
             }
+            return bounds;
         }
-        return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0,
-                sweepVertical, onlySweepAxisCollisions);
+
+        var bounds1 = getBounds(items1),
+            bounds2 = !items2 || items2 === items1
+                ? bounds1
+                : getBounds(items2);
+        return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
     },
 
     /**
@@ -67,14 +56,14 @@ var CollisionDetection = /** @lends CollisionDetection */{
      * the actual bounds. Broad bounds guarantee to contain the full curve,
      * but they are usually larger than the actual bounds of a curve.
      *
-     * This function takes the broad bounds of all curve values in the
-     * curveValues1 and curveValues2 arrays and calls findBoundsCollisions().
+     * This function takes the broad bounds of all curve values in the curves1
+     * and curves2 arrays and calls findBoundsCollisions().
      *
-     * @param {Array} curvesValues1 Array of curve values for which collisions
-     *     should be found.
-     * @param {Array} [curvesValues2] Array of curve values that the first
-     *     array should be compared with. If not provided, collisions between
-     *     curve bounds within the first arrray will be returned.
+     * @param {Array} curves1 Array of curve values for which collisions should
+     *     be found.
+     * @param {Array} [curves2] Array of curve values that the first array
+     *     should be compared with. If not provided, collisions between curve
+     *     bounds within the first arrray will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
      * @param {Boolean} [sweepVertical] If true, the sweep is performed along
@@ -82,40 +71,30 @@ var CollisionDetection = /** @lends CollisionDetection */{
      * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
      *     will be done on the secondary axis.
      * @returns {Array} Array containing for the bounds at the same index in
-     *     curveValues1 an array of the indexes of colliding bounds in
-     *     curveValues2
+     *     curves1 an array of the indexes of colliding bounds in curves2
      */
-    findCurveBoundsCollisions: function(curvesValues1, curvesValues2,
+    findCurveBoundsCollisions: function(curves1, curves2,
             tolerance, sweepVertical, onlySweepAxisCollisions) {
-        var min = Math.min,
-            max = Math.max,
-            bounds1 = new Array(curvesValues1.length),
-            bounds2;
-        for (var i = 0; i < bounds1.length; i++) {
-            var v1 = curvesValues1[i];
-            bounds1[i] = [
-                min(v1[0], v1[2], v1[4], v1[6]),
-                min(v1[1], v1[3], v1[5], v1[7]),
-                max(v1[0], v1[2], v1[4], v1[6]),
-                max(v1[1], v1[3], v1[5], v1[7])
-            ];
-        }
-        if (curvesValues2) {
-            if (curvesValues2 === curvesValues1) {
-                bounds2 = bounds1;
-            } else {
-                bounds2 = new Array(curvesValues2.length);
-                for (var i = 0; i < bounds2.length; i++) {
-                    var v2 = curvesValues2[i];
-                    bounds2[i] = [
-                        min(v2[0], v2[2], v2[4], v2[6]),
-                        min(v2[1], v2[3], v2[5], v2[7]),
-                        max(v2[0], v2[2], v2[4], v2[6]),
-                        max(v2[1], v2[3], v2[5], v2[7])
-                    ];
-                }
+        function getBounds(curves) {
+            var min = Math.min,
+                max = Math.max,
+                bounds = new Array(curves.length);
+            for (var i = 0; i < curves.length; i++) {
+                var v = curves[i];
+                bounds[i] = [
+                    min(v[0], v[2], v[4], v[6]),
+                    min(v[1], v[3], v[5], v[7]),
+                    max(v[0], v[2], v[4], v[6]),
+                    max(v[1], v[3], v[5], v[7])
+                ];
             }
+            return bounds;
         }
+
+        var bounds1 = getBounds(curves1),
+            bounds2 = !curves2 || curves2 === curves1
+                ? bounds1
+                : getBounds(curves2);
         return this.findBoundsCollisions(bounds1, bounds2,
                 tolerance || 0, sweepVertical, onlySweepAxisCollisions);
     },
@@ -156,21 +135,20 @@ var CollisionDetection = /** @lends CollisionDetection */{
      */
     findBoundsCollisions: function(boundsA, boundsB, tolerance,
         sweepVertical, onlySweepAxisCollisions) {
+        var self = !boundsB || boundsA === boundsB,
+            allBounds = self ? boundsA : boundsA.concat(boundsB),
+            lengthA = boundsA.length,
+            lengthAll = allBounds.length;
+
         // Binary search utility function.
         // For multiple same entries, this returns the rightmost entry.
         // https://en.wikipedia.org/wiki/Binary_search_algorithm#Procedure_for_finding_the_rightmost_element
-        var self = !boundsB || boundsA === boundsB,
-            allBounds = self ? boundsA : boundsA.concat(boundsB),
-            countA = boundsA.length,
-            countAll = allBounds.length,
-            lo, hi;
-
-        function binarySearch(indices, coordinateValue, coordinate) {
-            lo = 0;
-            hi = indices.length;
+        function binarySearch(indices, coord, value) {
+            var lo = 0,
+                hi = indices.length;
             while (lo < hi) {
                 var mid = (hi + lo) >>> 1; // Same as Math.floor((hi + lo) / 2)
-                if (allBounds[indices[mid]][coordinate] < coordinateValue) {
+                if (allBounds[indices[mid]][coord] < value) {
                     lo = mid + 1;
                 } else {
                     hi = mid;
@@ -182,73 +160,73 @@ var CollisionDetection = /** @lends CollisionDetection */{
         // Set coordinates for primary and secondary axis depending on sweep
         // direction. By default we sweep in horizontal direction, which
         // means x is the primary axis.
-        var coordP0 = sweepVertical ? 1 : 0,
-            coordP1 = coordP0 + 2,
-            coordS0 = sweepVertical ? 0 : 1,
-            coordS1 = coordS0 + 2;
+        var pri0 = sweepVertical ? 1 : 0,
+            pri1 = pri0 + 2,
+            sec0 = sweepVertical ? 0 : 1,
+            sec1 = sec0 + 2;
         // Create array with all indices sorted by lower boundary on primary
         // axis.
-        var allIndicesByP0 = new Array(countAll);
-        for (var i = 0; i < countAll; i++) {
-            allIndicesByP0[i] = i;
+        var allIndicesByPri0 = new Array(lengthAll);
+        for (var i = 0; i < lengthAll; i++) {
+            allIndicesByPri0[i] = i;
         }
-        allIndicesByP0.sort(function(i1, i2) {
-            return allBounds[i1][coordP0] - allBounds[i2][coordP0];
+        allIndicesByPri0.sort(function(i1, i2) {
+            return allBounds[i1][pri0] - allBounds[i2][pri0];
         });
         // Sweep along primary axis. Indices of active bounds are kept in an
         // array sorted by higher boundary on primary axis.
-        var activeIndicesByP1 = [],
-            allCollisions = new Array(countA);
-        for (var i = 0; i < countAll; i++) {
-            var currentIndex = allIndicesByP0[i],
-                currentBounds = allBounds[currentIndex],
-                currentOriginalIndex = self  // index in boundsA or boundsB
-                    ? currentIndex
-                    : currentIndex - countA,
-                isCurrentA = currentIndex < countA,
-                isCurrentB = self || currentIndex >= countA,
-                currentCollisions = isCurrentA ? [] : null;
-            if (activeIndicesByP1.length) {
-                // remove (prune) indices that are no longer active
-                var pruneCount = binarySearch(activeIndicesByP1,
-                        currentBounds[coordP0] - tolerance, coordP1) + 1;
-                activeIndicesByP1.splice(0, pruneCount);
-                // add collisions for current index
+        var activeIndicesByPri1 = [],
+            allCollisions = new Array(lengthA);
+        for (var i = 0; i < lengthAll; i++) {
+            var curIndex = allIndicesByPri0[i],
+                curBounds = allBounds[curIndex],
+                // The original index in boundsA or boundsB:
+                origIndex = self ? curIndex : curIndex - lengthA,
+                isCurrentA = curIndex < lengthA,
+                isCurrentB = self || !isCurrentA,
+                curCollisions = isCurrentA ? [] : null;
+            if (activeIndicesByPri1.length) {
+                // remove (prune) indices that are no longer active.
+                var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+                        curBounds[pri0] - tolerance) + 1;
+                activeIndicesByPri1.splice(0, pruneCount);
+                // Add collisions for current index.
                 if (self && onlySweepAxisCollisions) {
                     // All active indexes can be added, no further checks needed
-                    currentCollisions = currentCollisions.concat(
-                        activeIndicesByP1.slice());
+                    curCollisions = curCollisions.concat(activeIndicesByPri1);
                    // Add current index to collisions of all active indexes
-                    for (var j = 0; j < activeIndicesByP1.length; j++) {
-                        var activeIndex = activeIndicesByP1[j];
-                        allCollisions[activeIndex].push(currentOriginalIndex);
+                    for (var j = 0; j < activeIndicesByPri1.length; j++) {
+                        var activeIndex = activeIndicesByPri1[j];
+                        allCollisions[activeIndex].push(origIndex);
                     }
                 } else {
-                    var currentS1 = currentBounds[coordS1],
-                        currentS0 = currentBounds[coordS0];
-                    for (var j = 0; j < activeIndicesByP1.length; j++) {
-                        var activeIndex = activeIndicesByP1[j],
-                            isActiveA = activeIndex < countA,
-                            isActiveB = self || activeIndex >= countA;
-                        // Check secondary axis bounds if necessary
-                        if (onlySweepAxisCollisions ||
-                            (((isCurrentA && isActiveB) ||
-                                (isCurrentB && isActiveA)) &&
-                                currentS1 >=
-                                    allBounds[activeIndex][coordS0] -
-                                        tolerance &&
-                                    currentS0 <=
-                                        allBounds[activeIndex][coordS1] +
-                                            tolerance)) {
+                    var curSec1 = curBounds[sec1],
+                        curSec0 = curBounds[sec0];
+                    for (var j = 0; j < activeIndicesByPri1.length; j++) {
+                        var activeIndex = activeIndicesByPri1[j],
+                            activeBounds = allBounds[activeIndex],
+                            isActiveA = activeIndex < lengthA,
+                            isActiveB = self || activeIndex >= lengthA;
+
+                        // Check secondary axis bounds if necessary.
+                        if (
+                            onlySweepAxisCollisions ||
+                            (
+                                isCurrentA && isActiveB ||
+                                isCurrentB && isActiveA
+                            ) && (
+                                curSec1 >= activeBounds[sec0] - tolerance &&
+                                curSec0 <= activeBounds[sec1] + tolerance
+                            )
+                        ) {
                             // Add current index to collisions of active
                             // indices and vice versa.
                             if (isCurrentA && isActiveB) {
-                                currentCollisions.push(
-                                    self ? activeIndex : activeIndex - countA);
+                                curCollisions.push(
+                                    self ? activeIndex : activeIndex - lengthA);
                             }
                             if (isCurrentB && isActiveA) {
-                                allCollisions[activeIndex].push(
-                                    currentOriginalIndex);
+                                allCollisions[activeIndex].push(origIndex);
                             }
                         }
                     }
@@ -256,29 +234,27 @@ var CollisionDetection = /** @lends CollisionDetection */{
             }
             if (isCurrentA) {
                 if (boundsA === boundsB) {
-                    // if both arrays are the same, add self collision
-                    currentCollisions.push(currentIndex);
+                    // If both arrays are the same, add self collision.
+                    curCollisions.push(curIndex);
                 }
-                // add collisions for current index
-                allCollisions[currentIndex] = currentCollisions;
+                // Add collisions for current index.
+                allCollisions[curIndex] = curCollisions;
             }
-            // add current index to active indices. Keep array sorted by
-            // their higher boundary on the primary axis
-            if (activeIndicesByP1.length) {
-                var currentP1 = currentBounds[coordP1],
-                    insertIndex =
-                        binarySearch(activeIndicesByP1, currentP1, coordP1) + 1;
-                activeIndicesByP1.splice(insertIndex, 0, currentIndex);
+            // Add current index to active indices. Keep array sorted by
+            // their higher boundary on the primary axis.s
+            if (activeIndicesByPri1.length) {
+                var curPri1 = curBounds[pri1],
+                    index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+                activeIndicesByPri1.splice(index + 1, 0, curIndex);
             } else {
-                activeIndicesByP1.push(currentIndex);
+                activeIndicesByPri1.push(curIndex);
             }
         }
         // Sort collision indices in ascending order.
         for (var i = 0; i < allCollisions.length; i++) {
-            if (allCollisions[i]) {
-                allCollisions[i].sort(function(i1, i2) {
-                    return i1 - i2;
-                });
+            var collisions = allCollisions[i];
+            if (collisions) {
+                collisions.sort(function(i1, i2) { return i1 - i2; });
             }
         }
         return allCollisions;

From c82e5d41f7074533f3037553286ba35e442cb0f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 14 Dec 2019 19:40:00 +0100
Subject: [PATCH 145/181] Improve fix for nested group matrix reset

Closes #1711
---
 src/basic/Matrix.js |  7 +++---
 src/item/Item.js    | 61 ++++++++++++++++++++++++---------------------
 test/tests/Group.js | 31 ++++++++++++++++++++---
 3 files changed, 63 insertions(+), 36 deletions(-)

diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index 5ac409ab..c155bfba 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -185,15 +185,14 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * Attempts to apply the matrix to the content of item that it belongs to,
      * meaning its transformation is baked into the item's content or children.
      *
-     * @param {Boolean} [recursively=true] controls whether to apply transformations
-     * recursively on children
+     * @param {Boolean} [recursively=true] controls whether to apply
+     *     transformations recursively on children
      * @return {Boolean} {@true if the matrix was applied}
      */
     apply: function(recursively, _setApplyMatrix) {
         var owner = this._owner;
         if (owner) {
-            owner.transform(null, true, Base.pick(recursively, true),
-                    _setApplyMatrix);
+            owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
             // If the matrix was successfully applied, it will be reset now.
             return this.isIdentity();
         }
diff --git a/src/item/Item.js b/src/item/Item.js
index 3a45d61e..9e6de474 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -3509,19 +3509,22 @@ new function() { // Injection scope for hit-test functions shared with project
     // @param {String[]} flags array of any of the following: 'objects',
     //        'children', 'fill-gradients', 'fill-patterns', 'stroke-patterns',
     //        'lines'. Default: ['objects', 'children']
-    transform: function(matrix, _applyMatrix, _applyRecursively,
-            _setApplyMatrix) {
+    transform: function(matrix, _applyRecursively, _setApplyMatrix) {
         var _matrix = this._matrix,
-            // If no matrix is provided, or the matrix is the identity, we might
-            // still have some work to do in case _applyMatrix is true
             transformMatrix = matrix && !matrix.isIdentity(),
-            applyMatrix = (_applyMatrix || this._applyMatrix)
+            // If no matrix is provided, or the matrix is the identity, we might
+            // still have some work to do: _setApplyMatrix or _applyRecursively.
+            applyMatrix = (
+                _setApplyMatrix && this._canApplyMatrix ||
+                this._applyMatrix && (
                     // Don't apply _matrix if the result of concatenating with
                     // matrix would be identity.
-                    && ((!_matrix.isIdentity() || transformMatrix)
-                        // Even if it's an identity matrix, we still need to
-                        // recursively apply the matrix to children.
-                        || _applyMatrix && _applyRecursively && this._children);
+                    transformMatrix || !_matrix.isIdentity() ||
+                    // Even if it's an identity matrix, we may still need to
+                    // recursively apply the matrix to children.
+                    _applyRecursively && this._children
+                )
+            );
         // Bail out if there is nothing to do.
         if (!transformMatrix && !applyMatrix)
             return this;
@@ -3549,25 +3552,25 @@ new function() { // Injection scope for hit-test functions shared with project
             if (strokeColor)
                 strokeColor.transform(matrix);
         }
-        if (applyMatrix) {
-            // Set the internal _applyMatrix flag to true if we're told to do so.
+        // Call #_transformContent() now, if we need to directly apply the
+        // internal _matrix transformations to the item's content.
+        // Application is not possible on Raster, PointText, SymbolItem, since
+        // the matrix is where the actual transformation state is stored.
+
+        if (applyMatrix && (applyMatrix = this._transformContent(
+                _matrix, _applyRecursively, _setApplyMatrix))) {
+            // Pivot is provided in the parent's coordinate system, so transform
+            // it along too.
+            var pivot = this._pivot;
+            if (pivot)
+                _matrix._transformPoint(pivot, pivot, true);
+            // Reset the internal matrix to the identity transformation if
+            // it was possible to apply it, but do not notify owner of change.
+            _matrix.reset(true);
+            // Set the internal _applyMatrix flag to true if we're told to
+            // do so
             if (_setApplyMatrix && this._canApplyMatrix)
                 this._applyMatrix = true;
-            // Call #_transformContent() now, if we need to directly apply the
-            // internal _matrix transformations to the item's content.
-            // Application is not possible on Raster, PointText, SymbolItem, since
-            // the matrix is where the actual transformation state is stored.
-            if (this._applyMatrix && (applyMatrix = this._transformContent(_matrix,
-                    _applyRecursively, _setApplyMatrix))) {
-                // Pivot is provided in the parent's coordinate system, so transform
-                // it along too.
-                var pivot = this._pivot;
-                if (pivot)
-                    _matrix._transformPoint(pivot, pivot, true);
-                // Reset the internal matrix to the identity transformation if
-                // it was possible to apply it, but do not notify owner of change.
-                _matrix.reset(true);
-            }
         }
         // Calling _changed will clear _bounds and _position, but depending
         // on matrix we can calculate and set them again, so preserve them.
@@ -3619,9 +3622,9 @@ new function() { // Injection scope for hit-test functions shared with project
     _transformContent: function(matrix, applyRecursively, setApplyMatrix) {
         var children = this._children;
         if (children) {
-            for (var i = 0, l = children.length; i < l; i++)
-                children[i].transform(matrix, true, applyRecursively,
-                        setApplyMatrix);
+            for (var i = 0, l = children.length; i < l; i++) {
+                children[i].transform(matrix, applyRecursively, setApplyMatrix);
+            }
             return true;
         }
     },
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 55ab101a..5b9bc1b3 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -192,10 +192,35 @@ test(
 
 test('group.matrix with parent matrix applied (#1711)', function() {
     var child = new Group({ applyMatrix: false });
-    var parent = new Group([child]);
+    var parent = new Group({ applyMatrix: true, children: [child] });
     var scale = 1.1;
     var initial = child.scaling.x;
     parent.scale(scale);
-    var final = child.scaling.x;
-    equals(final, initial * scale);
+    equals(child.scaling.x, initial * scale);
+});
+
+test('Nested group.matrix.apply(true, true) with matrices not applied', function() {
+    var path = new Path({ applyMatrix: false });
+    var group = new Group({ applyMatrix: false, children: [path] });
+    var parent = new Group({ applyMatrix: false, children: [group] });
+    var grandParent = new Group({ applyMatrix: false, children: [parent] });
+    equals(function() {
+        return grandParent.applyMatrix;
+    }, false);
+    equals(function() {
+        return group.applyMatrix;
+    }, false);
+    equals(function() {
+        return path.applyMatrix;
+    }, false);
+    grandParent.matrix.apply(true, true);
+    equals(function() {
+        return grandParent.applyMatrix;
+    }, true);
+    equals(function() {
+        return group.applyMatrix;
+    }, true);
+    equals(function() {
+        return path.applyMatrix;
+    }, true);
 });

From a9ebe475e04435bb357cb26ce32f3a2f4b88986a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 14 Dec 2019 20:29:35 +0100
Subject: [PATCH 146/181] Some more optimizations for #1740

---
 src/path/Curve.js              |   2 +-
 src/path/PathItem.Boolean.js   | 105 +++++++++++++--------------------
 src/util/CollisionDetection.js |  23 +++++---
 3 files changed, 58 insertions(+), 72 deletions(-)

diff --git a/src/path/Curve.js b/src/path/Curve.js
index 258ca82f..c2f6c073 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2123,7 +2123,7 @@ new function() { // Scope for bezier intersection using fat-line clipping
             }
         }
         var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-                values1, self ? null : values2, epsilon);
+                values1, values2, epsilon);
         for (var index1 = 0; index1 < length1; index1++) {
             var curve1 = curves1[index1],
                 v1 = values1[index1];
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index cfef7004..ec64d05e 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -139,7 +139,7 @@ PathItem.inject(new function() {
             curves = [],
             paths;
 
-        function collect(paths) {
+        function collectPaths(paths) {
             for (var i = 0, l = paths.length; i < l; i++) {
                 var path = paths[i];
                 Base.push(segments, path._segments);
@@ -150,50 +150,35 @@ PathItem.inject(new function() {
             }
         }
 
+        function getCurves(indices) {
+            var list = [];
+            for (var i = 0, l = indices && indices.length; i < l; i++) {
+                list.push(curves[indices[i]]);
+            }
+            return list;
+        }
+
         if (crossings.length) {
             // Collect all segments and curves of both involved operands.
-            collect(paths1);
+            collectPaths(paths1);
             if (paths2)
-                collect(paths2);
+                collectPaths(paths2);
 
             var curvesValues = new Array(curves.length);
             for (var i = 0, l = curves.length; i < l; i++) {
                 curvesValues[i] = curves[i].getValues();
             }
-            var horCurveCollisions =
-                CollisionDetection.findCurveBoundsCollisions(
-                    curvesValues, curvesValues, 0, false, true);
-            var horCurvesMap = {};
+            var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+                    curvesValues, curvesValues, 0, true);
+            var curveCollisionsMap = {};
             for (var i = 0; i < curves.length; i++) {
                 var curve = curves[i],
-                    collidingCurves = [],
-                    collisionIndices = horCurveCollisions[i];
-                if (collisionIndices) {
-                    for (var j = 0; j < collisionIndices.length; j++) {
-                        collidingCurves.push(curves[collisionIndices[j]]);
-                    }
-                }
-                var pathId = curve.getPath().getId();
-                horCurvesMap[pathId] = horCurvesMap[pathId] || {};
-                horCurvesMap[pathId][curve.getIndex()] = collidingCurves;
-            }
-
-            var verCurveCollisions =
-                CollisionDetection.findCurveBoundsCollisions(
-                    curvesValues, curvesValues, 0, true, true);
-            var verCurvesMap = {};
-            for (var i = 0; i < curves.length; i++) {
-                var curve = curves[i],
-                    collidingCurves = [],
-                    collisionIndices = verCurveCollisions[i];
-                if (collisionIndices) {
-                    for (var j = 0; j < collisionIndices.length; j++) {
-                        collidingCurves.push(curves[collisionIndices[j]]);
-                    }
-                }
-                var pathId = curve.getPath().getId();
-                verCurvesMap[pathId] = verCurvesMap[pathId] || {};
-                verCurvesMap[pathId][curve.getIndex()] = collidingCurves;
+                    id = curve._path._id,
+                    map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+                map[curve.getIndex()] = {
+                    hor: getCurves(curveCollisions[i].hor),
+                    ver: getCurves(curveCollisions[i].ver)
+                };
             }
 
             // Propagate the winding contribution. Winding contribution of
@@ -202,14 +187,14 @@ PathItem.inject(new function() {
             // in all crossings:
             for (var i = 0, l = crossings.length; i < l; i++) {
                 propagateWinding(crossings[i]._segment, _path1, _path2,
-                        horCurvesMap, verCurvesMap, operator);
+                        curveCollisionsMap, operator);
             }
             for (var i = 0, l = segments.length; i < l; i++) {
                 var segment = segments[i],
                     inter = segment._intersection;
                 if (!segment._winding) {
                     propagateWinding(segment, _path1, _path2,
-                            horCurvesMap, verCurvesMap, operator);
+                            curveCollisionsMap, operator);
                 }
                 // See if all encountered segments in a path are overlaps.
                 if (!(inter && inter._overlap))
@@ -533,16 +518,9 @@ PathItem.inject(new function() {
      *
      * @param {Point} point the location for which to determine the winding
      *     contribution
-     * @param {Curve[]} curvesH The curves that describe the shape against which
+     * @param {Curve[]} curves The curves that describe the shape against which
      *     to check, as returned by {@link Path#curves} or
-     *     {@link CompoundPath#curves}. This only has to contain those curves
-     *     that can be crossed by a horizontal line through the point to be
-     *     checked.
-     * @param {Curve[]} curvesV  The curves that describe the shape against which
-     *     to check, as returned by {@link Path#curves} or
-     *     {@link CompoundPath#curves}. This only has to contain those curves
-     *     that can be crossed by a vertical line through the point to be
-     *     checked.
+     *     {@link CompoundPath#curves}.
      * @param {Boolean} [dir=false] the direction in which to determine the
      *     winding contribution, `false`: in x-direction, `true`: in y-direction
      * @param {Boolean} [closed=false] determines how areas should be closed
@@ -555,8 +533,14 @@ PathItem.inject(new function() {
      *     well as an indication whether the point was situated on the contour
      * @private
      */
-    function getWinding(point, curvesH, curvesV, dir, closed, dontFlip) {
-        var curves = !dir ? curvesV : curvesH;
+    function getWinding(point, curves, dir, closed, dontFlip) {
+        // `curves` can either be an array of curves, or an object containing of
+        // the form `{ hor: [], ver: [] }` (see `curveCollisionsMap`), with each
+        // key / value pair holding only those curves that can be crossed by a
+        // horizontal / vertical line through the point to be checked.
+        var curvesList = Array.isArray(curves)
+            ? curves
+            : curves[dir ? 'hor' : 'ver'];
         // Determine the index of the abscissa and ordinate values in the curve
         // values arrays, based on the direction:
         var ia = dir ? 1 : 0, // the abscissa index
@@ -671,7 +655,7 @@ PathItem.inject(new function() {
             // again with flipped direction and return that result instead.
             return !dontFlip && a > paL && a < paR
                     && Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-                    && getWinding(point, curvesH, curvesV, !dir, closed, true);
+                    && getWinding(point, curves, !dir, closed, true);
         }
 
         function handleCurve(v) {
@@ -702,12 +686,12 @@ PathItem.inject(new function() {
             }
         }
 
-        for (var i = 0, l = curves.length; i < l; i++) {
-            var curve = curves[i],
+        for (var i = 0, l = curvesList.length; i < l; i++) {
+            var curve = curvesList[i],
                 path = curve._path,
                 v = curve.getValues(),
                 res;
-            if (!i || curves[i - 1]._path !== path) {
+            if (!i || curvesList[i - 1]._path !== path) {
                 // We're on a new (sub-)path, so we need to determine values of
                 // the last non-horizontal curve on this path.
                 vPrev = null;
@@ -751,7 +735,7 @@ PathItem.inject(new function() {
             if (res = handleCurve(v))
                 return res;
 
-            if (i + 1 === l || curves[i + 1]._path !== path) {
+            if (i + 1 === l || curvesList[i + 1]._path !== path) {
                 // We're at the last curve of the current (sub-)path. If a
                 // closing curve was calculated at the beginning of it, handle
                 // it now to treat the path as closed:
@@ -792,7 +776,7 @@ PathItem.inject(new function() {
         };
     }
 
-    function propagateWinding(segment, path1, path2, horCurvesMap, verCurvesMap,
+    function propagateWinding(segment, path1, path2, curveCollisionsMap,
             operator) {
         // Here we try to determine the most likely winding number contribution
         // for the curve-chain starting with this segment. Once we have enough
@@ -859,13 +843,9 @@ PathItem.inject(new function() {
                             }
                         }
                     }
-                    if (!wind) {
-                        var pathId = path.getId(),
-                            curveIndex = curve.getIndex(),
-                            curvesH = horCurvesMap[pathId][curveIndex],
-                            curvesV = verCurvesMap[pathId][curveIndex];
-                        wind = getWinding(pt, curvesH, curvesV, dir, true);
-                    }
+                    wind =  wind || getWinding(
+                            pt, curveCollisionsMap[path._id][curve.getIndex()],
+                            dir, true);
                     if (wind.quality > winding.quality)
                         winding = wind;
                     break;
@@ -1141,8 +1121,7 @@ PathItem.inject(new function() {
          * @return {Number} the winding number
          */
         _getWinding: function(point, dir, closed) {
-            var curves = this.getCurves();
-            return getWinding(point, curves, curves, dir, closed);
+            return getWinding(point, this.getCurves(), dir, closed);
         },
 
         /**
diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
index 118af14b..442ab9d9 100644
--- a/src/util/CollisionDetection.js
+++ b/src/util/CollisionDetection.js
@@ -66,15 +66,12 @@ var CollisionDetection = /** @lends CollisionDetection */{
      *     bounds within the first arrray will be returned.
      * @param {Number} [tolerance] If provided, the tolerance will be added to
      *     all sides of each bounds when checking for collisions.
-     * @param {Boolean} [sweepVertical] If true, the sweep is performed along
-     *     the y-axis.
-     * @param {Boolean} [onlySweepAxisCollisions] If true, no collision checks
-     *     will be done on the secondary axis.
+     * @param {Boolean} [bothAxis] If true, the sweep is performed along both
+     *     axis, and the results include collisions for both: `{ hor, ver }`.
      * @returns {Array} Array containing for the bounds at the same index in
      *     curves1 an array of the indexes of colliding bounds in curves2
      */
-    findCurveBoundsCollisions: function(curves1, curves2,
-            tolerance, sweepVertical, onlySweepAxisCollisions) {
+    findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
         function getBounds(curves) {
             var min = Math.min,
                 max = Math.max,
@@ -95,8 +92,18 @@ var CollisionDetection = /** @lends CollisionDetection */{
             bounds2 = !curves2 || curves2 === curves1
                 ? bounds1
                 : getBounds(curves2);
-        return this.findBoundsCollisions(bounds1, bounds2,
-                tolerance || 0, sweepVertical, onlySweepAxisCollisions);
+        if (bothAxis) {
+            var hor = this.findBoundsCollisions(
+                    bounds1, bounds2, tolerance || 0, false, true),
+                ver = this.findBoundsCollisions(
+                    bounds1, bounds2, tolerance || 0, true, true),
+                list = [];
+            for (var i = 0, l = hor.length; i < l; i++) {
+                list[i] = { hor: hor[i], ver: ver[i] };
+            }
+            return list;
+        }
+        return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
     },
 
     /**

From 0dc51c2239586e1fb6c17704dc5804fe1cdb391f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 14 Dec 2019 20:32:00 +0100
Subject: [PATCH 147/181] Include BooleanOperations example from website

---
 examples/Paperjs.org/BooleanOperattions.html | 115 +++++++++++++++++++
 1 file changed, 115 insertions(+)
 create mode 100644 examples/Paperjs.org/BooleanOperattions.html

diff --git a/examples/Paperjs.org/BooleanOperattions.html b/examples/Paperjs.org/BooleanOperattions.html
new file mode 100644
index 00000000..930d7078
--- /dev/null
+++ b/examples/Paperjs.org/BooleanOperattions.html
@@ -0,0 +1,115 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Path Intersections</title>
+    <link rel="stylesheet" href="../css/style.css">
+    <script type="text/javascript" src="../../dist/paper-full.js"></script>
+    <script type="text/paperscript" canvas="canvas">
+        var text = new PointText({
+            position: view.center + [0, 200],
+            fillColor: 'black',
+            justification: 'center',
+            fontSize: 20
+        });
+
+        var originals = new Group({ insert: false }); // Don't insert in DOM.
+
+        var square = new Path.Rectangle({
+            position: view.center,
+            size: 300,
+            parent: originals,
+            fillColor: 'white'
+        });
+
+        // Make a ring using subtraction of two circles:
+        var inner = new Path.Circle({
+            center: view.center,
+            radius: 100,
+            parent: originals,
+            fillColor: 'white'
+        });
+
+        var outer = new Path.Circle({
+            center: view.center,
+            radius: 140,
+            parent: originals,
+            fillColor: 'white'
+        });
+
+        var ring = outer.subtract(inner);
+
+        var operations = ['unite', 'intersect', 'subtract', 'exclude', 'divide'];
+        var colors = ['red', 'green', 'blue', 'black'];
+        var curIndex = -1;
+        var operation, result, activeItem;
+
+        // Change the mode every 3 seconds:
+        setInterval(setMode, 3000);
+
+        // Set the initial mode:
+        setMode();
+
+        function setMode() {
+            curIndex++;
+            if (curIndex == operations.length * 2)
+                curIndex = 0;
+            operation = operations[curIndex % operations.length];
+        }
+
+        function onMouseDown(event) {
+            var hitResult = originals.hitTest(event.point);
+            activeItem = hitResult && hitResult.item;
+        }
+
+        function onMouseDrag(event) {
+            if (activeItem)
+                activeItem.position = event.point;
+        }
+
+        function onMouseUp() {
+            activeItem = null;
+            square.position = view.center;
+        }
+
+        function onFrame(event) {
+            if (activeItem != ring) {
+                // Move the ring around:
+                var offset = new Point(140, 80) * [Math.sin(event.count / 60), Math.sin(event.count / 40)];
+                ring.position = view.center + offset;
+            }
+
+            // Remove the result of the last path operation:
+            if (result)
+                result.remove();
+
+            // Perform the path operation on the ring:
+            if (curIndex < operations.length) {
+                result = square[operation](ring);
+                text.content = 'square.' + operation + '(ring)';
+            } else {
+                result = ring[operation](square);
+                text.content = 'ring.' + operation + '(square)';
+            }
+            result.selected = true;
+            result.fillColor = colors[curIndex % colors.length];
+            result.moveBelow(text);
+
+            // If the result is a group, color each of its children differently:
+            if (result instanceof Group) {
+                for (var i = 0; i < result.children.length; i++) {
+                    result.children[i].fillColor = colors[i];
+                }
+            }
+        };
+
+        function onResize() {
+            text.position = view.center + [0, 200];
+            square.position = view.center;
+        }
+    </script>
+</head>
+<body>
+<canvas id="canvas" resize></canvas>
+</body>
+</html>

From 2b62eb5cfa4f3db712d34c04a4e3f6e7bbed4f33 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Sun, 15 Dec 2019 14:31:31 +0100
Subject: [PATCH 148/181] Fix shape bounds when passing position in constructor
 (#1708)

In some special circumstances, when position was passed in constructor
and when position key was before size key, bounds were wrongly
calculated.
This ensure that when size is set, even the first time, bounds are
properly recalculated.
Closes #1686
---
 src/item/Shape.js   | 2 +-
 test/tests/Shape.js | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/item/Shape.js b/src/item/Shape.js
index 594ceddb..63bf40e2 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -101,8 +101,8 @@ var Shape = Item.extend(/** @lends Shape# */{
                 this._radius._set(width / 2, height / 2);
             }
             this._size._set(width, height);
-            this._changed(/*#=*/Change.GEOMETRY);
         }
+        this._changed(/*#=*/Change.GEOMETRY);
     },
 
     /**
diff --git a/test/tests/Shape.js b/test/tests/Shape.js
index 83c30bf7..a5f770d4 100644
--- a/test/tests/Shape.js
+++ b/test/tests/Shape.js
@@ -54,6 +54,14 @@ test('shape.toPath().toShape()', function() {
     });
 });
 
+test('new Shape.Rectangle() with position set before size', function() {
+    var shape1 = new Shape.Rectangle({
+        position: [0, 0],
+        size: new Size(100, 100)
+    });
+    equals(shape1.bounds.width, 100);
+});
+
 test('Shape.Rectangle radius works with negative size', function() {
     var shape = new Shape.Rectangle({
         center: [50, 50],

From dacfce049805a8fd19f6db1c26a64f1227e0d4df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 15 Dec 2019 14:34:46 +0100
Subject: [PATCH 149/181] Implement Base.readSupported() and improve argument
 reading in Shape

---
 src/basic/Rectangle.js | 22 ++++++-----
 src/core/Base.js       | 83 ++++++++++++++++++++++++++++++++----------
 src/item/Shape.js      | 11 ++++--
 3 files changed, 82 insertions(+), 34 deletions(-)

diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index 09a388aa..bd104ee6 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -98,11 +98,13 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
                         arg0.width || 0, arg0.height || 0);
                 read = 1;
             } else if (arg0.from === undefined && arg0.to === undefined) {
-                // Use Base.filter() to support whatever property the rectangle
-                // can take, but handle from/to separately below.
+                // Use `Base.readSupported()` to read and consume whatever
+                // property the rectangle can receive, but handle `from` / `to`
+                // separately below.
                 this._set(0, 0, 0, 0);
-                Base.filter(this, arg0);
-                read = 1;
+                if (Base.readSupported(arguments, this)) {
+                    read = 1;
+                }
             }
         }
         if (read === undefined) {
@@ -141,13 +143,13 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
             }
             this._set(x, y, width, height);
             read = arguments.__index;
-            // arguments.__filtered wouldn't survive the function call even if a
-            // previous arguments list was passed through Function#apply().
-            // Return it on the object instead, see Base.read()
-            var filtered = arguments.__filtered;
-            if (filtered)
-                this.__filtered = filtered;
         }
+        // arguments.__filtered wouldn't survive the function call even if a
+        // previous arguments list was passed through Function#apply().
+        // Return it on the object instead, see Base.read()
+        var filtered = arguments.__filtered;
+        if (filtered)
+            this.__filtered = filtered;
         if (this.__read)
             this.__read = read;
         return this;
diff --git a/src/core/Base.js b/src/core/Base.js
index 52d963af..dcb668ef 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -269,11 +269,11 @@ statics: /** @lends Base */{
     },
 
     /**
-     * Allows using of Base.read() mechanism in combination with reading named
-     * arguments form a passed property object literal. Calling Base.readNamed()
-     * can read both from such named properties and normal unnamed arguments
-     * through Base.read(). In use for example for the various
-     * Path.Constructors.
+     * Allows using of `Base.read()` mechanism in combination with reading named
+     * arguments form a passed property object literal. Calling
+     * `Base.readNamed()` can read both from such named properties and normal
+     * unnamed arguments through `Base.read()`. In use for example for
+     * the various `Path` constructors in `Path.Constructors.js`.
      *
      * @param {Array} list the list to read from, either an arguments object or
      *     a normal array
@@ -287,24 +287,68 @@ statics: /** @lends Base */{
      */
     readNamed: function(list, name, start, options, amount) {
         var value = this.getNamed(list, name),
-            hasObject = value !== undefined;
-        if (hasObject) {
-            // Create a _filtered object that inherits from list[0], and
+            hasValue = value !== undefined;
+        if (hasValue) {
+            // Create a _filtered object that inherits from `source`, and
             // override all fields that were already read with undefined.
             var filtered = list.__filtered;
             if (!filtered) {
-                filtered = list.__filtered = Base.create(list[0]);
-                // Point _unfiltered to the original so Base#_set() can
-                // execute hasOwnProperty on it.
-                filtered.__unfiltered = list[0];
+                var source = this.getSource(list);
+                filtered = list.__filtered = Base.create(source);
+                // Point __unfiltered to the original, so `Base.filter()` can
+                // use it to get all keys to iterate over.
+                filtered.__unfiltered = source;
             }
             // delete wouldn't work since the masked parent's value would
             // shine through.
             filtered[name] = undefined;
         }
-        var l = hasObject ? [value] : list,
-            res = this.read(l, start, options, amount);
-        return res;
+        return this.read(hasValue ? [value] : list, start, options, amount);
+    },
+
+    /**
+     * If `list[0]` is a source object, calls `Base.readNamed()` for each key in
+     * it that is supported on `dest`, consuming these values.
+     *
+     * @param {Array} list the list to read from, either an arguments object or
+     *     a normal array
+     * @param {Object} dest the object on which to set the supported properties
+     * @return {Boolean} {@true if any property was read from the source object}
+     */
+    readSupported: function(list, dest) {
+        var source = this.getSource(list),
+            that = this,
+            read = false;
+        if (source) {
+            // If `source` is a filtered object, we get the keys from the the
+            // original object (it's parent / prototype). See _filtered
+            // inheritance trick in the argument reading code.
+            Object.keys(source).forEach(function(key) {
+                if (key in dest) {
+                    var value = that.readNamed(list, key);
+                    // Due to the _filtered inheritance trick, undefined is used
+                    // to mask already consumed named arguments.
+                    if (value !== undefined) {
+                        dest[key] = value;
+                    }
+                    read = true;
+                }
+            });
+        }
+        return read;
+    },
+
+    /**
+     * @return the arguments object if the list provides one at `list[0]`
+     */
+    getSource: function(list) {
+        var source = list.__source;
+        if (source === undefined) {
+            var arg = list.length === 1 && list[0];
+            source = list.__source = arg && Base.isPlainObject(arg)
+                ? arg : null;
+        }
+        return source;
     },
 
     /**
@@ -314,12 +358,11 @@ statics: /** @lends Base */{
      *     provided, it returns the whole arguments object
      */
     getNamed: function(list, name) {
-        var arg = list[0];
-        if (list._hasObject === undefined)
-            list._hasObject = list.length === 1 && Base.isPlainObject(arg);
-        if (list._hasObject)
+        var source = this.getSource(list);
+        if (source) {
             // Return the whole arguments object if no name is provided.
-            return name ? arg[name] : list.__filtered || arg;
+            return name ? source[name] : list.__filtered || source;
+        }
     },
 
     /**
diff --git a/src/item/Shape.js b/src/item/Shape.js
index 63bf40e2..e9b7e340 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -82,7 +82,7 @@ var Shape = Item.extend(/** @lends Shape# */{
     setSize: function(/* size */) {
         var size = Size.read(arguments);
         if (!this._size) {
-            // First time, e.g. whean reading from JSON...
+            // First time, e.g. when reading from JSON...
             this._size = size.clone();
         } else if (!this._size.equals(size)) {
             var type = this._type,
@@ -101,8 +101,8 @@ var Shape = Item.extend(/** @lends Shape# */{
                 this._radius._set(width / 2, height / 2);
             }
             this._size._set(width, height);
+            this._changed(/*#=*/Change.GEOMETRY);
         }
-        this._changed(/*#=*/Change.GEOMETRY);
     },
 
     /**
@@ -130,7 +130,7 @@ var Shape = Item.extend(/** @lends Shape# */{
         } else {
             radius = Size.read(arguments);
             if (!this._radius) {
-                // First time, e.g. whean reading from JSON...
+                // First time, e.g. when reading from JSON...
                 this._radius = radius.clone();
             } else {
                 if (this._radius.equals(radius))
@@ -390,10 +390,13 @@ new function() { // Scope for _contains() and _hitTestSelf() code.
 // Mess with indentation in order to get more line-space below:
 statics: new function() {
     function createShape(type, point, size, radius, args) {
-        var item = new Shape(Base.getNamed(args), point);
+        // Use `Base.create()` to avoid calling `initialize()` until after the
+        // internal fields are set here, then call `_initialize()` directly:
+        var item = Base.create(Shape.prototype);
         item._type = type;
         item._size = size;
         item._radius = radius;
+        item._initialize(Base.getNamed(args), point);
         return item;
     }
 

From c7d85b663edb728ec78fffa9f828435eaf78d9c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 15 Dec 2019 19:40:40 +0100
Subject: [PATCH 150/181] Use minifiable reference to arguments for repeated
 use

---
 src/basic/Matrix.js           | 20 ++++----
 src/basic/Point.js            | 20 ++++----
 src/basic/Rectangle.js        | 22 ++++-----
 src/item/Item.js              | 15 +++---
 src/item/Raster.js            |  5 +-
 src/item/Shape.js             | 19 ++++----
 src/path/Path.Constructors.js | 55 ++++++++++++----------
 src/path/Path.js              | 87 ++++++++++++++++++++---------------
 src/view/View.js              |  5 +-
 9 files changed, 141 insertions(+), 107 deletions(-)

diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index c155bfba..4bddb67b 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -71,10 +71,11 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * @param {Matrix} matrix the matrix to copy the values from
      */
     initialize: function Matrix(arg, _dontNotify) {
-        var count = arguments.length,
+        var args = arguments,
+            count = args.length,
             ok = true;
         if (count >= 6) { // >= 6 to pass on optional _dontNotify argument.
-            this._set.apply(this, arguments);
+            this._set.apply(this, args);
         } else if (count === 1 || count === 2) {
             // Support both Matrix and Array arguments through #_set(), and pass
             // on the optional _dontNotify argument:
@@ -246,8 +247,9 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * @return {Matrix} this affine transform
      */
     scale: function(/* scale, center */) {
-        var scale = Point.read(arguments),
-            center = Point.read(arguments, 0, { readNull: true });
+        var args = arguments,
+            scale = Point.read(args),
+            center = Point.read(args, 0, { readNull: true });
         if (center)
             this.translate(center);
         this._a *= scale.x;
@@ -327,8 +329,9 @@ var Matrix = Base.extend(/** @lends Matrix# */{
     shear: function(/* shear, center */) {
         // Do not modify point, center, since that would arguments of which
         // we're reading from!
-        var shear = Point.read(arguments),
-            center = Point.read(arguments, 0, { readNull: true });
+        var args = arguments,
+            shear = Point.read(args),
+            center = Point.read(args, 0, { readNull: true });
         if (center)
             this.translate(center);
         var a = this._a,
@@ -363,8 +366,9 @@ var Matrix = Base.extend(/** @lends Matrix# */{
      * @return {Matrix} this affine transform
      */
     skew: function(/* skew, center */) {
-        var skew = Point.read(arguments),
-            center = Point.read(arguments, 0, { readNull: true }),
+        var args = arguments,
+            skew = Point.read(args),
+            center = Point.read(args, 0, { readNull: true }),
             toRadians = Math.PI / 180,
             shear = new Point(Math.tan(skew.x * toRadians),
                 Math.tan(skew.y * toRadians));
diff --git a/src/basic/Point.js b/src/basic/Point.js
index 9765162a..eaca9822 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -433,11 +433,12 @@ var Point = Base.extend(/** @lends Point# */{
      * @return {Number}
      */
     getDistance: function(/* point, squared */) {
-        var point = Point.read(arguments),
+        var args = arguments,
+            point = Point.read(args),
             x = point.x - this.x,
             y = point.y - this.y,
             d = x * x + y * y,
-            squared = Base.read(arguments);
+            squared = Base.read(args);
         return squared ? d : Math.sqrt(d);
     },
 
@@ -711,8 +712,9 @@ var Point = Base.extend(/** @lends Point# */{
      * @return {Boolean} {@true if it is within the given distance}
      */
     isClose: function(/* point, tolerance */) {
-        var point = Point.read(arguments),
-            tolerance = Base.read(arguments);
+        var args = arguments,
+            point = Point.read(args),
+            tolerance = Base.read(args);
         return this.getDistance(point) <= tolerance;
     },
 
@@ -937,8 +939,9 @@ var Point = Base.extend(/** @lends Point# */{
          * [point1, point2, point3].reduce(Point.min) // {x: 60, y: 5}
          */
         min: function(/* point1, point2 */) {
-            var point1 = Point.read(arguments),
-                point2 = Point.read(arguments);
+            var args = arguments,
+                point1 = Point.read(args),
+                point2 = Point.read(args);
             return new Point(
                 Math.min(point1.x, point2.x),
                 Math.min(point1.y, point2.y)
@@ -968,8 +971,9 @@ var Point = Base.extend(/** @lends Point# */{
          * [point1, point2, point3].reduce(Point.max) // {x: 250, y: 100}
          */
         max: function(/* point1, point2 */) {
-            var point1 = Point.read(arguments),
-                point2 = Point.read(arguments);
+            var args = arguments,
+                point1 = Point.read(args),
+                point2 = Point.read(args);
             return new Point(
                 Math.max(point1.x, point2.x),
                 Math.max(point1.y, point2.y)
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index bd104ee6..be80cee3 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -76,7 +76,8 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
      * @param {Rectangle} rectangle
      */
     initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-        var type = typeof arg0,
+        var args = arguments,
+            type = typeof arg0,
             read;
         if (type === 'number') {
             // new Rectangle(x, y, width, height)
@@ -86,7 +87,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
             // new Rectangle(), new Rectangle(null)
             this._set(0, 0, 0, 0);
             read = arg0 === null ? 1 : 0;
-        } else if (arguments.length === 1) {
+        } else if (args.length === 1) {
             // This can either be an array, or an object literal.
             if (Array.isArray(arg0)) {
                 this._set.apply(this, arg0);
@@ -102,7 +103,7 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
                 // property the rectangle can receive, but handle `from` / `to`
                 // separately below.
                 this._set(0, 0, 0, 0);
-                if (Base.readSupported(arguments, this)) {
+                if (Base.readSupported(args, this)) {
                     read = 1;
                 }
             }
@@ -113,17 +114,16 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
             // We're supporting both reading from a normal arguments list and
             // covering the Rectangle({ from: , to: }) constructor, through
             // Point.readNamed().
-            var frm = Point.readNamed(arguments, 'from'),
-                next = Base.peek(arguments),
+            var frm = Point.readNamed(args, 'from'),
+                next = Base.peek(args),
                 x = frm.x,
                 y = frm.y,
                 width,
                 height;
-            if (next && next.x !== undefined
-                    || Base.hasNamed(arguments, 'to')) {
+            if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
                 // new Rectangle(from, to)
                 // Read above why we can use readNamed() to cover both cases.
-                var to = Point.readNamed(arguments, 'to');
+                var to = Point.readNamed(args, 'to');
                 width = to.x - x;
                 height = to.y - y;
                 // Check if horizontal or vertical order needs to be reversed.
@@ -137,17 +137,17 @@ var Rectangle = Base.extend(/** @lends Rectangle# */{
                 }
             } else {
                 // new Rectangle(point, size)
-                var size = Size.read(arguments);
+                var size = Size.read(args);
                 width = size.width;
                 height = size.height;
             }
             this._set(x, y, width, height);
-            read = arguments.__index;
+            read = args.__index;
         }
         // arguments.__filtered wouldn't survive the function call even if a
         // previous arguments list was passed through Function#apply().
         // Return it on the object instead, see Base.read()
-        var filtered = arguments.__filtered;
+        var filtered = args.__filtered;
         if (filtered)
             this.__filtered = filtered;
         if (this.__read)
diff --git a/src/item/Item.js b/src/item/Item.js
index 9e6de474..5feb9045 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -1877,14 +1877,16 @@ new function() { // Injection scope for various item event handlers
 },
 new function() { // Injection scope for hit-test functions shared with project
     function hitTest(/* point, options */) {
+        var args = arguments;
         return this._hitTest(
-                Point.read(arguments),
-                HitResult.getOptions(arguments));
+                Point.read(args),
+                HitResult.getOptions(args));
     }
 
     function hitTestAll(/* point, options */) {
-        var point = Point.read(arguments),
-            options = HitResult.getOptions(arguments),
+        var args = arguments,
+            point = Point.read(args),
+            options = HitResult.getOptions(args),
             all = [];
         this._hitTest(point, new Base({ all: all }, options));
         return all;
@@ -3328,8 +3330,9 @@ new function() { // Injection scope for hit-test functions shared with project
 }, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
     var rotate = key === 'rotate';
     this[key] = function(/* value, center */) {
-        var value = (rotate ? Base : Point).read(arguments),
-            center = Point.read(arguments, 0, { readNull: true });
+        var args = arguments,
+            value = (rotate ? Base : Point).read(args),
+            center = Point.read(args, 0, { readNull: true });
         return this.transform(new Matrix()[key](value,
                 center || this.getPosition(true)));
     };
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 6453fe0f..fee172f5 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -696,8 +696,9 @@ var Raster = Item.extend(/** @lends Raster# */{
      * @param {Color} color the color that the pixel will be set to
      */
     setPixel: function(/* point, color */) {
-        var point = Point.read(arguments),
-            color = Color.read(arguments),
+        var args = arguments,
+            point = Point.read(args),
+            color = Color.read(args),
             components = color._convert('rgb'),
             alpha = color._alpha,
             ctx = this.getContext(true),
diff --git a/src/item/Shape.js b/src/item/Shape.js
index e9b7e340..3fe45773 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -430,10 +430,11 @@ statics: new function() {
          * });
          */
         Circle: function(/* center, radius */) {
-            var center = Point.readNamed(arguments, 'center'),
-                radius = Base.readNamed(arguments, 'radius');
+            var args = arguments,
+                center = Point.readNamed(args, 'center'),
+                radius = Base.readNamed(args, 'radius');
             return createShape('circle', center, new Size(radius * 2), radius,
-                    arguments);
+                    args);
         },
 
         /**
@@ -527,11 +528,12 @@ statics: new function() {
          * });
          */
         Rectangle: function(/* rectangle */) {
-            var rect = Rectangle.readNamed(arguments, 'rectangle'),
-                radius = Size.min(Size.readNamed(arguments, 'radius'),
+            var args = arguments,
+                rect = Rectangle.readNamed(args, 'rectangle'),
+                radius = Size.min(Size.readNamed(args, 'radius'),
                         rect.getSize(true).divide(2));
             return createShape('rectangle', rect.getCenter(true),
-                    rect.getSize(true), radius, arguments);
+                    rect.getSize(true), radius, args);
         },
 
         /**
@@ -570,10 +572,11 @@ statics: new function() {
          * });
          */
         Ellipse: function(/* rectangle */) {
-            var ellipse = Shape._readEllipse(arguments),
+            var args = arguments,
+                ellipse = Shape._readEllipse(args),
                 radius = ellipse.radius;
             return createShape('ellipse', ellipse.center, radius.multiply(2),
-                    radius, arguments);
+                    radius, args);
         },
 
         // Private method to read ellipse center and radius from arguments list,
diff --git a/src/path/Path.Constructors.js b/src/path/Path.Constructors.js
index ea92ee16..b6db94f6 100644
--- a/src/path/Path.Constructors.js
+++ b/src/path/Path.Constructors.js
@@ -79,10 +79,11 @@ Path.inject({ statics: new function() {
          * });
          */
         Line: function(/* from, to */) {
+            var args = arguments;
             return createPath([
-                new Segment(Point.readNamed(arguments, 'from')),
-                new Segment(Point.readNamed(arguments, 'to'))
-            ], false, arguments);
+                new Segment(Point.readNamed(args, 'from')),
+                new Segment(Point.readNamed(args, 'to'))
+            ], false, args);
         },
 
         /**
@@ -114,9 +115,10 @@ Path.inject({ statics: new function() {
          * });
          */
         Circle: function(/* center, radius */) {
-            var center = Point.readNamed(arguments, 'center'),
-                radius = Base.readNamed(arguments, 'radius');
-            return createEllipse(center, new Size(radius), arguments);
+            var args = arguments,
+                center = Point.readNamed(args, 'center'),
+                radius = Base.readNamed(args, 'radius');
+            return createEllipse(center, new Size(radius), args);
         },
 
         /**
@@ -210,8 +212,9 @@ Path.inject({ statics: new function() {
          * });
          */
         Rectangle: function(/* rectangle */) {
-            var rect = Rectangle.readNamed(arguments, 'rectangle'),
-                radius = Size.readNamed(arguments, 'radius', 0,
+            var args = arguments,
+                rect = Rectangle.readNamed(args, 'rectangle'),
+                radius = Size.readNamed(args, 'radius', 0,
                         { readNull: true }),
                 bl = rect.getBottomLeft(true),
                 tl = rect.getTopLeft(true),
@@ -242,7 +245,7 @@ Path.inject({ statics: new function() {
                     new Segment(br.subtract(rx, 0), [hx, 0])
                 ];
             }
-            return createPath(segments, true, arguments);
+            return createPath(segments, true, args);
         },
 
         /**
@@ -286,8 +289,9 @@ Path.inject({ statics: new function() {
          * });
          */
         Ellipse: function(/* rectangle */) {
-            var ellipse = Shape._readEllipse(arguments);
-            return createEllipse(ellipse.center, ellipse.radius, arguments);
+            var args = arguments,
+                ellipse = Shape._readEllipse(args);
+            return createEllipse(ellipse.center, ellipse.radius, args);
         },
 
         /**
@@ -330,10 +334,11 @@ Path.inject({ statics: new function() {
          * });
          */
         Arc: function(/* from, through, to */) {
-            var from = Point.readNamed(arguments, 'from'),
-                through = Point.readNamed(arguments, 'through'),
-                to = Point.readNamed(arguments, 'to'),
-                props = Base.getNamed(arguments),
+            var args = arguments,
+                from = Point.readNamed(args, 'from'),
+                through = Point.readNamed(args, 'through'),
+                to = Point.readNamed(args, 'to'),
+                props = Base.getNamed(args),
                 // See createPath() for an explanation of the following sequence
                 path = new Path(props && props.insert == false
                         && Item.NO_INSERT);
@@ -376,9 +381,10 @@ Path.inject({ statics: new function() {
          * });
          */
         RegularPolygon: function(/* center, sides, radius */) {
-            var center = Point.readNamed(arguments, 'center'),
-                sides = Base.readNamed(arguments, 'sides'),
-                radius = Base.readNamed(arguments, 'radius'),
+            var args = arguments,
+                center = Point.readNamed(args, 'center'),
+                sides = Base.readNamed(args, 'sides'),
+                radius = Base.readNamed(args, 'radius'),
                 step = 360 / sides,
                 three = sides % 3 === 0,
                 vector = new Point(0, three ? -radius : radius),
@@ -387,7 +393,7 @@ Path.inject({ statics: new function() {
             for (var i = 0; i < sides; i++)
                 segments[i] = new Segment(center.add(
                     vector.rotate((i + offset) * step)));
-            return createPath(segments, true, arguments);
+            return createPath(segments, true, args);
         },
 
         /**
@@ -431,17 +437,18 @@ Path.inject({ statics: new function() {
          * });
          */
         Star: function(/* center, points, radius1, radius2 */) {
-            var center = Point.readNamed(arguments, 'center'),
-                points = Base.readNamed(arguments, 'points') * 2,
-                radius1 = Base.readNamed(arguments, 'radius1'),
-                radius2 = Base.readNamed(arguments, 'radius2'),
+            var args = arguments,
+                center = Point.readNamed(args, 'center'),
+                points = Base.readNamed(args, 'points') * 2,
+                radius1 = Base.readNamed(args, 'radius1'),
+                radius2 = Base.readNamed(args, 'radius2'),
                 step = 360 / points,
                 vector = new Point(0, -1),
                 segments = new Array(points);
             for (var i = 0; i < points; i++)
                 segments[i] = new Segment(center.add(vector.rotate(step * i)
                         .multiply(i % 2 ? radius2 : radius1)));
-            return createPath(segments, true, arguments);
+            return createPath(segments, true, args);
         }
     };
 }});
diff --git a/src/path/Path.js b/src/path/Path.js
index aa25ce07..f28d4234 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -98,15 +98,16 @@ var Path = PathItem.extend(/** @lends Path# */{
         // check its first entry for object as well.
         // But first see if segments are directly passed at all. If not, try
         // _set(arg).
-        var segments = Array.isArray(arg)
+        var args = arguments,
+            segments = Array.isArray(arg)
             ? typeof arg[0] === 'object'
                 ? arg
-                : arguments
+                : args
             // See if it behaves like a segment or a point, but filter out
             // rectangles, as accepted by some Path.Constructor constructors.
             : arg && (arg.size === undefined && (arg.x !== undefined
                     || arg.point !== undefined))
-                ? arguments
+                ? args
                 : null;
         // Always call setSegments() to initialize a few related variables.
         if (segments && segments.length > 0) {
@@ -548,11 +549,12 @@ var Path = PathItem.extend(/** @lends Path# */{
      * path.add(new Point(170, 75));
      */
     add: function(segment1 /*, segment2, ... */) {
-        return arguments.length > 1 && typeof segment1 !== 'number'
+        var args = arguments;
+        return args.length > 1 && typeof segment1 !== 'number'
             // addSegments
-            ? this._add(Segment.readList(arguments))
+            ? this._add(Segment.readList(args))
             // addSegment
-            : this._add([ Segment.read(arguments) ])[0];
+            : this._add([ Segment.read(args) ])[0];
     },
 
     /**
@@ -592,11 +594,12 @@ var Path = PathItem.extend(/** @lends Path# */{
      * myPath.segments[2].selected = true;
      */
     insert: function(index, segment1 /*, segment2, ... */) {
-        return arguments.length > 2 && typeof segment1 !== 'number'
+        var args = arguments;
+        return args.length > 2 && typeof segment1 !== 'number'
             // insertSegments
-            ? this._add(Segment.readList(arguments, 1), index)
+            ? this._add(Segment.readList(args, 1), index)
             // insertSegment
-            : this._add([ Segment.read(arguments, 1) ], index)[0];
+            : this._add([ Segment.read(args, 1) ], index)[0];
     },
 
     addSegment: function(/* segment */) {
@@ -2401,9 +2404,10 @@ new function() { // PostScript-style drawing commands
         },
 
         cubicCurveTo: function(/* handle1, handle2, to */) {
-            var handle1 = Point.read(arguments),
-                handle2 = Point.read(arguments),
-                to = Point.read(arguments),
+            var args = arguments,
+                handle1 = Point.read(args),
+                handle2 = Point.read(args),
+                to = Point.read(args),
                 // First modify the current segment:
                 current = getCurrentSegment(this);
             // Convert to relative values:
@@ -2413,8 +2417,9 @@ new function() { // PostScript-style drawing commands
         },
 
         quadraticCurveTo: function(/* handle, to */) {
-            var handle = Point.read(arguments),
-                to = Point.read(arguments),
+            var args = arguments,
+                handle = Point.read(args),
+                to = Point.read(args),
                 current = getCurrentSegment(this)._point;
             // This is exact:
             // If we have the three quad points: A E D,
@@ -2429,9 +2434,10 @@ new function() { // PostScript-style drawing commands
         },
 
         curveTo: function(/* through, to, time */) {
-            var through = Point.read(arguments),
-                to = Point.read(arguments),
-                t = Base.pick(Base.read(arguments), 0.5),
+            var args = arguments,
+                through = Point.read(args),
+                to = Point.read(args),
+                t = Base.pick(Base.read(args), 0.5),
                 t1 = 1 - t,
                 current = getCurrentSegment(this)._point,
                 // handle = (through - (1 - t)^2 * current - t^2 * to) /
@@ -2447,15 +2453,16 @@ new function() { // PostScript-style drawing commands
         arcTo: function(/* to, clockwise | through, to
                 | to, radius, rotation, clockwise, large */) {
             // Get the start point:
-            var abs = Math.abs,
+            var args = arguments,
+                abs = Math.abs,
                 sqrt = Math.sqrt,
                 current = getCurrentSegment(this),
                 from = current._point,
-                to = Point.read(arguments),
+                to = Point.read(args),
                 through,
                 // Peek at next value to see if it's clockwise, with true as the
                 // default value.
-                peek = Base.peek(arguments),
+                peek = Base.peek(args),
                 clockwise = Base.pick(peek, true),
                 center, extent, vector, matrix;
             // We're handling three different approaches to drawing arcs in one
@@ -2465,15 +2472,15 @@ new function() { // PostScript-style drawing commands
                 var middle = from.add(to).divide(2),
                 through = middle.add(middle.subtract(from).rotate(
                         clockwise ? -90 : 90));
-            } else if (Base.remain(arguments) <= 2) {
+            } else if (Base.remain(args) <= 2) {
                 // #2: arcTo(through, to)
                 through = to;
-                to = Point.read(arguments);
+                to = Point.read(args);
             } else if (!from.equals(to)) {
                 // #3: arcTo(to, radius, rotation, clockwise, large)
                 // Draw arc in SVG style, but only if `from` and `to` are not
                 // equal (#1613).
-                var radius = Size.read(arguments),
+                var radius = Size.read(args),
                     isZero = Numerical.isZero;
                 // If rx = 0 or ry = 0 then this arc is treated as a
                 // straight line joining the endpoints.
@@ -2482,9 +2489,9 @@ new function() { // PostScript-style drawing commands
                     return this.lineTo(to);
                 // See for an explanation of the following calculations:
                 // https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
-                var rotation = Base.read(arguments),
-                    clockwise = !!Base.read(arguments),
-                    large = !!Base.read(arguments),
+                var rotation = Base.read(args),
+                    clockwise = !!Base.read(args),
+                    large = !!Base.read(args),
                     middle = from.add(to).divide(2),
                     pt = from.subtract(middle).rotate(-rotation),
                     x = pt.x,
@@ -2620,40 +2627,44 @@ new function() { // PostScript-style drawing commands
         },
 
         curveBy: function(/* through, to, parameter */) {
-            var through = Point.read(arguments),
-                to = Point.read(arguments),
-                parameter = Base.read(arguments),
+            var args = arguments,
+                through = Point.read(args),
+                to = Point.read(args),
+                parameter = Base.read(args),
                 current = getCurrentSegment(this)._point;
             this.curveTo(current.add(through), current.add(to), parameter);
         },
 
         cubicCurveBy: function(/* handle1, handle2, to */) {
-            var handle1 = Point.read(arguments),
-                handle2 = Point.read(arguments),
-                to = Point.read(arguments),
+            var args = arguments,
+                handle1 = Point.read(args),
+                handle2 = Point.read(args),
+                to = Point.read(args),
                 current = getCurrentSegment(this)._point;
             this.cubicCurveTo(current.add(handle1), current.add(handle2),
                     current.add(to));
         },
 
         quadraticCurveBy: function(/* handle, to */) {
-            var handle = Point.read(arguments),
-                to = Point.read(arguments),
+            var args = arguments,
+                handle = Point.read(args),
+                to = Point.read(args),
                 current = getCurrentSegment(this)._point;
             this.quadraticCurveTo(current.add(handle), current.add(to));
         },
 
         // TODO: Implement version for: (to, radius, rotation, clockwise, large)
         arcBy: function(/* to, clockwise | through, to */) {
-            var current = getCurrentSegment(this)._point,
-                point = current.add(Point.read(arguments)),
+            var args = arguments,
+                current = getCurrentSegment(this)._point,
+                point = current.add(Point.read(args)),
                 // Peek at next value to see if it's clockwise, with true as
                 // default value.
-                clockwise = Base.pick(Base.peek(arguments), true);
+                clockwise = Base.pick(Base.peek(args), true);
             if (typeof clockwise === 'boolean') {
                 this.arcTo(point, clockwise);
             } else {
-                this.arcTo(point, current.add(Point.read(arguments)));
+                this.arcTo(point, current.add(Point.read(args)));
             }
         },
 
diff --git a/src/view/View.js b/src/view/View.js
index 6e45717c..8a7bc1a7 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -480,8 +480,9 @@ var View = Base.extend(Emitter, /** @lends View# */{
 }, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
     var rotate = key === 'rotate';
     this[key] = function(/* value, center */) {
-        var value = (rotate ? Base : Point).read(arguments),
-            center = Point.read(arguments, 0, { readNull: true });
+        var args = arguments,
+            value = (rotate ? Base : Point).read(args),
+            center = Point.read(args, 0, { readNull: true });
         return this.transform(new Matrix()[key](value,
                 center || this.getCenter(true)));
     };

From 64eb5ac1c461fd75c8c1310e21e3ba0881dbd46b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 15 Dec 2019 21:25:00 +0100
Subject: [PATCH 151/181] Update CHANGELOG with latest changes

---
 CHANGELOG.md | 36 +++++++++++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7df06fcb..9b853250 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,18 +1,44 @@
 # Change Log
 
+## `unreleased`
+
+### Added
+
+- Allow paper core import in TypeScript (#1713).
+- Boolean: Improve performance from `O(n^2)` to nearly `O(n)` by the use of the
+  sweep and prune algorithm (#1737).
+- Docs: Add support for nullable values.
+
+### Fixed
+
+- Fix `PathItem#getCrossing()` to not return overlaps (#1409).
+- Fix regression in `Curve.getIntersections()` (#1638).
+- Fix edge cases in `CurveLocation.isCrossing()` (#1419, #1263).
+- Fix `SymbolItem#hitTestAll()` to return only one match per symbol item
+  (#1680).
+- Fix handling of negative `Shape` sizes (#1733).
+- Fix parsing of RGB `Color` strings with percentages (#1736).
+- Fix `Shape` bounds when passing position in constructor (#1686).
+- Prevent nested group matrix from reset when transforming parent (#1711).
+- Boolean: Fix edge cases in overlap detection (#1262).
+- Boolean: Add check for paths with only one segment (#1351).
+- Boolean: Correctly handle open filled paths (#1647).
+- Boolean: Avoid winding number edge cases (#1619).
+- Docs: Fix some documentation return types (#1679).
+
 ## `0.12.3`
 
+### Added
+
+- Add documentation for `Item#internalBounds`.
+
 ### Fixed
 
 - Fix regression in `Color` change propagation (#1672, #1674).
 - SVG Export: Fix viewport size of exported `Symbol` (#1668).
 - Handle non-invertible matrices in `Item#contains()` (#1651).
 - Improve documentation for `Item#clipMask` (#1673).
-- Improve TypeScript definitions (#1659, #1663, #1664, #1667)
-
-### Added
-
-- Add documentation for `Item#internalBounds`.
+- Improve TypeScript definitions (#1659, #1663, #1664, #1667).
 
 ## `0.12.2`
 

From 4bc92ce1321392c59474f6ec14fdea9a7365b113 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 15 Dec 2019 21:46:29 +0100
Subject: [PATCH 152/181] Release version 0.12.4

---
 CHANGELOG.md                |     2 +-
 dist/paper-core.js          | 15636 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17384 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |   473 +-
 package.json                |     2 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 8 files changed, 33216 insertions(+), 287 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9b853250..1e52db29 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## `unreleased`
+## `0.12.4`
 
 ### Added
 
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..68dda931
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15635 @@
+/*!
+ * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sun Dec 15 21:25:00 2019 +0100
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.4",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 64);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..fefe9cf5
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17383 @@
+/*!
+ * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sun Dec 15 21:25:00 2019 +0100
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.4",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = this._opacity,
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContent || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = this._opacity;
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setCurve: function(curve) {
+		var path = curve._path;
+		this._path = path;
+		this._version = path ? path._version : 0;
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		this._setCurve(segment.getCurve());
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 64);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		for (var i = 1; i < length; i++)
+			addJoin(segments[i], join);
+		if (closed) {
+			addJoin(segments[0], join);
+		} else if (length > 0) {
+			addCap(segments[0], cap);
+			addCap(segments[segments.length - 1], cap);
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._prev)
+					inter = inter._prev;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object' ? svg : new self.DOMParser()
+						.parseFromString(svg, 'image/svg+xml');
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^.*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			sourceMaps = options.sourceMaps,
+			source = options.source || code,
+			lineBreaks = /\r\n|\n|\r/mg,
+			offset = options.offset || 0,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		walkAST(parse(code, {
+			ranges: true,
+			preserveParens: true,
+			sourceType: 'module'
+		}));
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 4f6635d5..f0cc9398 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.3 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,107 +9,12 @@
  *
  * All rights reserved.
  *
- * Date: Sat Jun 22 14:16:49 2019 +0200
+ * Date: Sun Dec 15 21:25:00 2019 +0100
  *
  * This is an auto-generated type definition.
  */
 
-declare module paper {
-    /** 
-     * The version of Paper.js, as a string.
-     */
-    let version: string
-
-    /** 
-     * Gives access to paper's configurable settings.
-     * 
-     * @option [settings.insertItems=true] {Boolean} controls whether newly
-     *     created items are automatically inserted into the scene graph, by
-     *     adding them to {@link Project#activeLayer}
-     * @option [settings.applyMatrix=true] {Boolean} controls what value newly
-     *     created items have their {@link Item#applyMatrix} property set to
-     *     (Note that not all items can set this to `false`)
-     * @option [settings.handleSize=4] {Number} the size of the curve handles
-     *     when drawing selections
-     * @option [settings.hitTolerance=0] {Number} the default tolerance for hit-
-     *     tests, when no value is specified
-     */
-    let settings: any
-
-    /** 
-     * The currently active project.
-     */
-    let project: Project | null
-
-    /** 
-     * The list of all open projects within the current Paper.js context.
-     */
-    let projects: Project[] | null
-
-    /** 
-     * The reference to the active project's view.
-     */
-    let view: View
-
-    /** 
-     * The reference to the active tool.
-     */
-    let tool: Tool | null
-
-    /** 
-     * The list of available tools.
-     */
-    let tools: Tool[] | null
-
-
-    /** 
-     * Compiles the PaperScript code into a compiled function and executes it.
-     * The compiled function receives all properties of this {@link PaperScope}
-     * as arguments, to emulate a global scope with unaffected performance. It
-     * also installs global view and tool handlers automatically on the
-     * respective objects.
-     * 
-     * @option options.url {String} the url of the source, for source-map
-     *     debugging
-     * @option options.source {String} the source to be used for the source-
-     *     mapping, in case the code that's passed in has already been mingled.
-     * 
-     * @param code - the PaperScript code
-     * @param options - the compilation options
-     */
-    function execute(code: string, options?: object): void
-
-    /** 
-     * Injects the paper scope into any other given scope. Can be used for
-     * example to inject the currently active PaperScope into the window's
-     * global scope, to emulate PaperScript-style globally accessible Paper
-     * classes and objects.
-     * 
-     * <b>Please note:</b> Using this method may override native constructors
-     * (e.g. Path). This may cause problems when using Paper.js in conjunction
-     * with other libraries that rely on these constructors. Keep the library
-     * scoped if you encounter issues caused by this.
-     */
-    function install(scope: any): void
-
-    /** 
-     * Sets up an empty project for us. If a canvas is provided, it also creates
-     * a {@link View} for it, both linked to this scope.
-     * 
-     * @param element - the HTML canvas element
-     * this scope should be associated with, or an ID string by which to find
-     * the element, or the size of the canvas to be created for usage in a web
-     * worker.
-     */
-    function setup(element: HTMLCanvasElement | string | Size): void
-
-    /** 
-     * Activates this PaperScope, so all newly created items will be placed
-     * in its active project.
-     */
-    function activate(): void
-
-
+declare namespace paper {
 
     /** 
      * All properties and functions that expect color values in the form
@@ -121,7 +26,7 @@ declare module paper {
         /** 
          * The type of the color as a string.
          */
-        type: string | null
+        type: string
 
         /** 
          * The color components that define the color, including the alpha value
@@ -133,59 +38,59 @@ declare module paper {
          * The color's alpha value as a number between `0` and `1`.
          * All colors of the different subclasses support alpha values.
          */
-        alpha: number | null
+        alpha: number
 
         /** 
          * The amount of red in the color as a value between `0` and `1`.
          */
-        red: number | null
+        red: number
 
         /** 
          * The amount of green in the color as a value between `0` and `1`.
          */
-        green: number | null
+        green: number
 
         /** 
          * The amount of blue in the color as a value between `0` and `1`.
          */
-        blue: number | null
+        blue: number
 
         /** 
          * The amount of gray in the color as a value between `0` and `1`.
          */
-        gray: number | null
+        gray: number
 
         /** 
          * The hue of the color as a value in degrees between `0` and `360`.
          */
-        hue: number | null
+        hue: number
 
         /** 
          * The saturation of the color as a value between `0` and `1`.
          */
-        saturation: number | null
+        saturation: number
 
         /** 
          * The brightness of the color as a value between `0` and `1`.
          */
-        brightness: number | null
+        brightness: number
 
         /** 
          * The lightness of the color as a value between `0` and `1`.
          * 
          * Note that all other components are shared with HSB.
          */
-        lightness: number | null
+        lightness: number
 
         /** 
          * The gradient object describing the type of gradient and the stops.
          */
-        gradient: Gradient | null
+        gradient: Gradient
 
         /** 
          * The highlight point of the gradient.
          */
-        highlight: Point | null
+        highlight: Point
 
 
         /** 
@@ -446,7 +351,7 @@ declare module paper {
          * 
          * @see Path#closed
          */
-        closed: boolean | null
+        closed: boolean
 
         /** 
          * The first Segment contained within the compound-path, a short-cut to
@@ -529,22 +434,22 @@ declare module paper {
         /** 
          * The first anchor point of the curve.
          */
-        point1: Point | null
+        point1: Point
 
         /** 
          * The second anchor point of the curve.
          */
-        point2: Point | null
+        point2: Point
 
         /** 
          * The handle point that describes the tangent in the first anchor point.
          */
-        handle1: Point | null
+        handle1: Point
 
         /** 
          * The handle point that describes the tangent in the second anchor point.
          */
-        handle2: Point | null
+        handle2: Point
 
         /** 
          * The first segment of the curve.
@@ -581,7 +486,7 @@ declare module paper {
         /** 
          * Specifies whether the points and handles of the curve are selected.
          */
-        selected: boolean | null
+        selected: boolean
 
         /** 
          * An array of 8 float values, describing this curve's geometry in four
@@ -614,17 +519,17 @@ declare module paper {
         /** 
          * The bounding rectangle of the curve excluding stroke width.
          */
-        bounds: Rectangle | null
+        bounds: Rectangle
 
         /** 
          * The bounding rectangle of the curve including stroke width.
          */
-        strokeBounds: Rectangle | null
+        strokeBounds: Rectangle
 
         /** 
          * The bounding rectangle of the curve including handles.
          */
-        handleBounds: Rectangle | null
+        handleBounds: Rectangle
 
 
         /** 
@@ -1278,12 +1183,12 @@ declare module paper {
         /** 
          * The gradient stops on the gradient ramp.
          */
-        stops: GradientStop[] | null
+        stops: GradientStop[]
 
         /** 
          * Specifies whether the gradient is radial or linear.
          */
-        radial: boolean | null
+        radial: boolean
 
 
         /** 
@@ -1307,12 +1212,12 @@ declare module paper {
         /** 
          * The ramp-point of the gradient stop as a value between `0` and `1`.
          */
-        offset: number | null
+        offset: number
 
         /** 
          * The color of the gradient stop.
          */
-        color: Color | null
+        color: Color
 
 
         /** 
@@ -1343,7 +1248,7 @@ declare module paper {
          * `true`, the first child in the group is automatically defined as the
          * clipping mask.
          */
-        clipped: boolean | null
+        clipped: boolean
 
 
         /** 
@@ -1374,24 +1279,24 @@ declare module paper {
          * Describes the type of the hit result. For example, if you hit a segment
          * point, the type would be `'segment'`.
          */
-        type: string | null
+        type: string
 
         /** 
          * If the HitResult has a {@link HitResult#type} of `'bounds'`, this
          * property describes which corner of the bounding rectangle was hit.
          */
-        name: string | null
+        name: string
 
         /** 
          * The item that was hit.
          */
-        item: Item | null
+        item: Item
 
         /** 
          * If the HitResult has a type of 'curve' or 'stroke', this property gives
          * more information about the exact position that was hit on the path.
          */
-        location: CurveLocation | null
+        location: CurveLocation
 
         /** 
          * If the HitResult has a type of 'pixel', this property refers to the color
@@ -1404,13 +1309,13 @@ declare module paper {
          * 'handle-out', this property refers to the segment that was hit or that
          * is closest to the hitResult.location on the curve.
          */
-        segment: Segment | null
+        segment: Segment
 
         /** 
          * Describes the actual coordinates of the segment, handle or bounding box
          * corner that was hit.
          */
-        point: Point | null
+        point: Point
 
 
     }
@@ -1432,30 +1337,30 @@ declare module paper {
         /** 
          * The class name of the item as a string.
          */
-        className: string | null
+        className: string
 
         /** 
          * The name of the item. If the item has a name, it can be accessed by name
          * through its parent's children list.
          */
-        name: string | null
+        name: string
 
         /** 
          * The path style of the item.
          */
-        style: Style | null
+        style: Style
 
         /** 
          * Specifies whether the item is locked. When set to `true`, item
          * interactions with the mouse are disabled.
          */
-        locked: boolean | null
+        locked: boolean
 
         /** 
          * Specifies whether the item is visible. When set to `false`, the item
          * won't be drawn.
          */
-        visible: boolean | null
+        visible: boolean
 
         /** 
          * The blend mode with which the item is composited onto the canvas. Both
@@ -1463,12 +1368,12 @@ declare module paper {
          * are supported. If blend-modes cannot be rendered natively, they are
          * emulated. Be aware that emulation can have an impact on performance.
          */
-        blendMode: string | null
+        blendMode: string
 
         /** 
          * The opacity of the item as a value between `0` and `1`.
          */
-        opacity: number | null
+        opacity: number
 
         /** 
          * Specifies whether the item is selected. This will also return `true` for
@@ -1485,14 +1390,14 @@ declare module paper {
          * @see Curve#selected
          * @see Point#selected
          */
-        selected: boolean | null
+        selected: boolean
 
         /** 
          * Specifies whether the item defines a clip mask. This can only be set on
          * paths and compound paths, and only if the item is already contained
          * within a clipping group.
          */
-        clipMask: boolean | null
+        clipMask: boolean
 
         /** 
          * A plain javascript object which can be used to store
@@ -1505,7 +1410,7 @@ declare module paper {
          * default, this is the {@link Rectangle#center} of the item's
          * {@link #bounds} rectangle.
          */
-        position: Point | null
+        position: Point
 
         /** 
          * The item's pivot point specified in the item coordinate system, defining
@@ -1514,22 +1419,22 @@ declare module paper {
          * meaning the {@link Rectangle#center} of the item's {@link #bounds}
          * rectangle is used as pivot.
          */
-        pivot: Point | null
+        pivot: Point
 
         /** 
          * The bounding rectangle of the item excluding stroke width.
          */
-        bounds: Rectangle | null
+        bounds: Rectangle
 
         /** 
          * The bounding rectangle of the item including stroke width.
          */
-        strokeBounds: Rectangle | null
+        strokeBounds: Rectangle
 
         /** 
          * The bounding rectangle of the item including handles.
          */
-        handleBounds: Rectangle | null
+        handleBounds: Rectangle
 
         /** 
          * The bounding rectangle of the item without any matrix transformations.
@@ -1538,7 +1443,7 @@ declare module paper {
          * want to draw something of the same size, position, rotation, and scaling,
          * like a selection frame.
          */
-        internalBounds: Rectangle | null
+        internalBounds: Rectangle
 
         /** 
          * The current rotation angle of the item, as described by its
@@ -1547,7 +1452,7 @@ declare module paper {
          * {@link #applyMatrix} set to `false`, meaning they do not directly bake
          * transformations into their content.
          */
-        rotation: number | null
+        rotation: number
 
         /** 
          * The current scale factor of the item, as described by its
@@ -1556,13 +1461,13 @@ declare module paper {
          * {@link #applyMatrix} set to `false`, meaning they do not directly bake
          * transformations into their content.
          */
-        scaling: Point | null
+        scaling: Point
 
         /** 
          * The item's transformation matrix, defining position and dimensions in
          * relation to its parent item in which it is contained.
          */
-        matrix: Matrix | null
+        matrix: Matrix
 
         /** 
          * The item's global transformation matrix in relation to the global project
@@ -1586,7 +1491,7 @@ declare module paper {
          * on to the segments in {@link Path} items, the children of {@link Group}
          * items, etc.).
          */
-        applyMatrix: boolean | null
+        applyMatrix: boolean
 
         /** 
          * The project that this item belongs to.
@@ -1606,7 +1511,7 @@ declare module paper {
         /** 
          * The item that this item is contained within.
          */
-        parent: Item | null
+        parent: Item
 
         /** 
          * The children items contained within this item. Items that define a
@@ -1618,7 +1523,7 @@ declare module paper {
          * {@link Item#removeChildren}. To add items to the children list, use
          * {@link Item#addChild} or {@link Item#insertChild}.
          */
-        children: Item[] | null
+        children: Item[]
 
         /** 
          * The first item contained within this item. This is a shortcut for
@@ -1655,36 +1560,36 @@ declare module paper {
         /** 
          * The width of the stroke.
          */
-        strokeWidth: number | null
+        strokeWidth: number
 
         /** 
          * The shape to be used at the beginning and end of open {@link Path} items,
          * when they have a stroke.
          */
-        strokeCap: string | null
+        strokeCap: string
 
         /** 
          * The shape to be used at the segments and corners of {@link Path} items
          * when they have a stroke.
          */
-        strokeJoin: string | null
+        strokeJoin: string
 
         /** 
          * The dash offset of the stroke.
          */
-        dashOffset: number | null
+        dashOffset: number
 
         /** 
          * Specifies whether the stroke is to be drawn taking the current affine
          * transformation into account (the default behavior), or whether it should
          * appear as a non-scaling stroke.
          */
-        strokeScaling: boolean | null
+        strokeScaling: boolean
 
         /** 
          * Specifies an array containing the dash and gap lengths of the stroke.
          */
-        dashArray: number[] | null
+        dashArray: number[]
 
         /** 
          * The miter limit of the stroke.
@@ -1694,7 +1599,7 @@ declare module paper {
          * miterLimit imposes a limit on the ratio of the miter length to the
          * {@link Item#strokeWidth}.
          */
-        miterLimit: number | null
+        miterLimit: number
 
         /** 
          * The fill color of the item.
@@ -1705,7 +1610,7 @@ declare module paper {
          * The fill-rule with which the shape gets filled. Please note that only
          * modern browsers support fill-rules other than `'nonzero'`.
          */
-        fillRule: string | null
+        fillRule: string
 
         /** 
          * The shadow color.
@@ -1715,12 +1620,12 @@ declare module paper {
         /** 
          * The shadow's blur radius.
          */
-        shadowBlur: number | null
+        shadowBlur: number
 
         /** 
          * The shadow's offset.
          */
-        shadowOffset: Point | null
+        shadowOffset: Point
 
         /** 
          * The color the item is highlighted with when selected. If the item does
@@ -2320,10 +2225,8 @@ declare module paper {
          * 
          * @param recursively - whether an item with children should be
          * considered empty if all its descendants are empty
-         * 
-         * @return Boolean
          */
-        isEmpty(recursively?: boolean): void
+        isEmpty(recursively?: boolean): boolean
 
         /** 
          * Checks whether the item has a fill.
@@ -2786,20 +2689,20 @@ declare module paper {
         /** 
          * The type of mouse event.
          */
-        type: string | null
+        type: string
 
         /** 
          * The character representation of the key that caused this key event,
          * taking into account the current key-modifiers (e.g. shift, control,
          * caps-lock, etc.)
          */
-        character: string | null
+        character: string
 
         /** 
          * The key that caused this key event, either as a lower-case character or
          * special key descriptor.
          */
-        key: string | null
+        key: string
 
 
         /** 
@@ -2872,37 +2775,37 @@ declare module paper {
          * The value that affects the transformation along the x axis when scaling
          * or rotating, positioned at (0, 0) in the transformation matrix.
          */
-        a: number | null
+        a: number
 
         /** 
          * The value that affects the transformation along the y axis when rotating
          * or skewing, positioned at (1, 0) in the transformation matrix.
          */
-        b: number | null
+        b: number
 
         /** 
          * The value that affects the transformation along the x axis when rotating
          * or skewing, positioned at (0, 1) in the transformation matrix.
          */
-        c: number | null
+        c: number
 
         /** 
          * The value that affects the transformation along the y axis when scaling
          * or rotating, positioned at (1, 1) in the transformation matrix.
          */
-        d: number | null
+        d: number
 
         /** 
          * The distance by which to translate along the x axis, positioned at (2, 0)
          * in the transformation matrix.
          */
-        tx: number | null
+        tx: number
 
         /** 
          * The distance by which to translate along the y axis, positioned at (2, 1)
          * in the transformation matrix.
          */
-        ty: number | null
+        ty: number
 
         /** 
          * The matrix values as an array, in the same sequence as they are passed
@@ -2998,8 +2901,8 @@ declare module paper {
          * Attempts to apply the matrix to the content of item that it belongs to,
          * meaning its transformation is baked into the item's content or children.
          * 
-         * @param recursively - controls whether to apply transformations
-         * recursively on children
+         * @param recursively - controls whether to apply
+         *     transformations recursively on children
          * 
          * @return true if the matrix was applied
          */
@@ -3249,20 +3152,20 @@ declare module paper {
         /** 
          * The type of mouse event.
          */
-        type: string | null
+        type: string
 
         /** 
          * The position of the mouse in project coordinates when the event was
          * fired.
          */
-        point: Point | null
+        point: Point
 
         /** 
          * The item that dispatched the event. It is different from
          * {@link #currentTarget} when the event handler is called during
          * the bubbling phase of the event.
          */
-        target: Item | null
+        target: Item
 
         /** 
          * The current target for the event, as the event traverses the scene graph.
@@ -3270,10 +3173,10 @@ declare module paper {
          * opposed to {@link #target} which identifies the element on
          * which the event occurred.
          */
-        currentTarget: Item | null
+        currentTarget: Item
 
         
-        delta: Point | null
+        delta: Point
 
 
         /** 
@@ -3328,12 +3231,12 @@ declare module paper {
         /** 
          * The currently active project.
          */
-        project: Project | null
+        project: Project
 
         /** 
          * The list of all open projects within the current Paper.js context.
          */
-        projects: Project[] | null
+        projects: Project[]
 
         /** 
          * The reference to the active project's view.
@@ -3343,12 +3246,12 @@ declare module paper {
         /** 
          * The reference to the active tool.
          */
-        tool: Tool | null
+        tool: Tool
 
         /** 
          * The list of available tools.
          */
-        tools: Tool[] | null
+        tools: Tool[]
 
         Color: typeof Color
         CompoundPath: typeof CompoundPath
@@ -3365,6 +3268,7 @@ declare module paper {
         Layer: typeof Layer
         Matrix: typeof Matrix
         MouseEvent: typeof MouseEvent
+        PaperScope: typeof PaperScope
         PaperScript: typeof PaperScript
         Path: typeof Path
         PathItem: typeof PathItem
@@ -3440,7 +3344,7 @@ declare module paper {
         /** 
          * Retrieves a PaperScope object with the given scope id.
          */
-        static get(id: any): void
+        static get(id: any): PaperScope
 
     }
 
@@ -3510,7 +3414,7 @@ declare module paper {
         /** 
          * The segments contained within the path.
          */
-        segments: Segment[] | null
+        segments: Segment[]
 
         /** 
          * The first Segment contained within the path.
@@ -3541,7 +3445,7 @@ declare module paper {
          * Specifies whether the path is closed. If it is closed, Paper.js connects
          * the first and last segments.
          */
-        closed: boolean | null
+        closed: boolean
 
         /** 
          * The approximate length of the path.
@@ -3558,7 +3462,7 @@ declare module paper {
          * Specifies whether the path and all its segments are selected. Cannot be
          * `true` on an empty path.
          */
-        fullySelected: boolean | null
+        fullySelected: boolean
 
 
         /** 
@@ -3608,7 +3512,7 @@ declare module paper {
          * the same object, e.g. if the segment to be added already belongs to
          * another path.
          */
-        add(...segment: (Segment | Point | Number[])[]): Segment | Segment[]
+        add(...segment: (Segment | Point | number[])[]): Segment | Segment[]
 
         /** 
          * Inserts one or more segments at a given index in the list of this path's
@@ -4038,12 +3942,12 @@ declare module paper {
          * @see Path#area
          * @see CompoundPath#area
          */
-        clockwise: boolean | null
+        clockwise: boolean
 
         /** 
          * The path's geometry, formatted as SVG style path data.
          */
-        pathData: string | null
+        pathData: string
 
 
         /** 
@@ -4555,12 +4459,12 @@ declare module paper {
         /** 
          * The x coordinate of the point
          */
-        x: number | null
+        x: number
 
         /** 
          * The y coordinate of the point
          */
-        y: number | null
+        y: number
 
         /** 
          * The length of the vector that is represented by this point's coordinates.
@@ -4568,17 +4472,17 @@ declare module paper {
          * = 0`, `y = 0`) to the point's location. Setting the length changes the
          * location but keeps the vector's angle.
          */
-        length: number | null
+        length: number
 
         /** 
          * The vector's angle in degrees, measured from the x-axis to the vector.
          */
-        angle: number | null
+        angle: number
 
         /** 
          * The vector's angle in radians, measured from the x-axis to the vector.
          */
-        angleInRadians: number | null
+        angleInRadians: number
 
         /** 
          * The quadrant of the {@link #angle} of the point.
@@ -4603,7 +4507,7 @@ declare module paper {
          * Paper.js renders selected points on top of your project. This is very
          * useful when debugging.
          */
-        selected: boolean | null
+        selected: boolean
 
 
         /** 
@@ -4992,7 +4896,7 @@ declare module paper {
         /** 
          * The PointText's anchor point
          */
-        point: Point | null
+        point: Point
 
 
         /** 
@@ -5041,7 +4945,7 @@ declare module paper {
          * The currently active path style. All selected items and newly
          * created items will be styled with this style.
          */
-        currentStyle: Style | null
+        currentStyle: Style
 
         /** 
          * The index of the project in the {@link PaperScope#projects} list.
@@ -5367,17 +5271,17 @@ declare module paper {
         /** 
          * The size of the raster in pixels.
          */
-        size: Size | null
+        size: Size
 
         /** 
          * The width of the raster in pixels.
          */
-        width: number | null
+        width: number
 
         /** 
          * The height of the raster in pixels.
          */
-        height: number | null
+        height: number
 
         /** 
          * The loading state of the raster image.
@@ -5397,7 +5301,7 @@ declare module paper {
          * the raster even if the image has already finished loading before, or if
          * we are setting the raster to a canvas.
          */
-        image: HTMLImageElement | HTMLCanvasElement | null
+        image: HTMLImageElement | HTMLCanvasElement
 
         /** 
          * The Canvas object of the raster. If the raster was created from an image,
@@ -5405,12 +5309,12 @@ declare module paper {
          * image into it. Depending on security policies, this might fail, in which
          * case `null` is returned instead.
          */
-        canvas: HTMLCanvasElement | null
+        canvas: HTMLCanvasElement
 
         /** 
          * The Canvas 2D drawing context of the raster.
          */
-        context: CanvasRenderingContext2D | null
+        context: CanvasRenderingContext2D
 
         /** 
          * The source of the raster, which can be set using a DOM Image, a Canvas,
@@ -5421,7 +5325,7 @@ declare module paper {
          * Note that for consistency, a {@link #onLoad} event will be triggered on
          * the raster even if the image has already finished loading before.
          */
-        source: HTMLImageElement | HTMLCanvasElement | string | null
+        source: HTMLImageElement | HTMLCanvasElement | string
 
         /** 
          * The crossOrigin value to be used when loading the image resource, in
@@ -5429,13 +5333,13 @@ declare module paper {
          * {@link #source} property in order to always work (e.g. when the image is
          * cached in the browser).
          */
-        crossOrigin: string | null
+        crossOrigin: string
 
         /** 
          * Specifies if the raster should be smoothed when scaled up or if the
          * pixels should be scaled up by repeating the nearest neighboring pixels.
          */
-        smoothing: boolean | null
+        smoothing: boolean
 
         /** 
          * The event handler function to be called when the underlying image has
@@ -5583,101 +5487,101 @@ declare module paper {
         /** 
          * The x position of the rectangle.
          */
-        x: number | null
+        x: number
 
         /** 
          * The y position of the rectangle.
          */
-        y: number | null
+        y: number
 
         /** 
          * The width of the rectangle.
          */
-        width: number | null
+        width: number
 
         /** 
          * The height of the rectangle.
          */
-        height: number | null
+        height: number
 
         /** 
          * The top-left point of the rectangle
          */
-        point: Point | null
+        point: Point
 
         /** 
          * The size of the rectangle
          */
-        size: Size | null
+        size: Size
 
         /** 
          * The position of the left hand side of the rectangle. Note that this
          * doesn't move the whole rectangle; the right hand side stays where it was.
          */
-        left: number | null
+        left: number
 
         /** 
          * The top coordinate of the rectangle. Note that this doesn't move the
          * whole rectangle: the bottom won't move.
          */
-        top: number | null
+        top: number
 
         /** 
          * The position of the right hand side of the rectangle. Note that this
          * doesn't move the whole rectangle; the left hand side stays where it was.
          */
-        right: number | null
+        right: number
 
         /** 
          * The bottom coordinate of the rectangle. Note that this doesn't move the
          * whole rectangle: the top won't move.
          */
-        bottom: number | null
+        bottom: number
 
         /** 
          * The center point of the rectangle.
          */
-        center: Point | null
+        center: Point
 
         /** 
          * The top-left point of the rectangle.
          */
-        topLeft: Point | null
+        topLeft: Point
 
         /** 
          * The top-right point of the rectangle.
          */
-        topRight: Point | null
+        topRight: Point
 
         /** 
          * The bottom-left point of the rectangle.
          */
-        bottomLeft: Point | null
+        bottomLeft: Point
 
         /** 
          * The bottom-right point of the rectangle.
          */
-        bottomRight: Point | null
+        bottomRight: Point
 
         /** 
          * The left-center point of the rectangle.
          */
-        leftCenter: Point | null
+        leftCenter: Point
 
         /** 
          * The top-center point of the rectangle.
          */
-        topCenter: Point | null
+        topCenter: Point
 
         /** 
          * The right-center point of the rectangle.
          */
-        rightCenter: Point | null
+        rightCenter: Point
 
         /** 
          * The bottom-center point of the rectangle.
          */
-        bottomCenter: Point | null
+        bottomCenter: Point
 
         /** 
          * The area of the rectangle.
@@ -5690,7 +5594,7 @@ declare module paper {
          * Paper.js draws the bounds of items with selected bounds on top of
          * your project. This is very useful when debugging.
          */
-        selected: boolean | null
+        selected: boolean
 
 
         /** 
@@ -5893,24 +5797,24 @@ declare module paper {
         /** 
          * The anchor point of the segment.
          */
-        point: Point | null
+        point: Point
 
         /** 
          * The handle point relative to the anchor point of the segment that
          * describes the in tangent of the segment.
          */
-        handleIn: Point | null
+        handleIn: Point
 
         /** 
          * The handle point relative to the anchor point of the segment that
          * describes the out tangent of the segment.
          */
-        handleOut: Point | null
+        handleOut: Point
 
         /** 
          * Specifies whether the segment is selected.
          */
-        selected: boolean | null
+        selected: boolean
 
         /** 
          * The index of the segment in the {@link Path#segments} array that the
@@ -6109,18 +6013,18 @@ declare module paper {
         /** 
          * The type of shape of the item as a string.
          */
-        type: string | null
+        type: string
 
         /** 
          * The size of the shape.
          */
-        size: Size | null
+        size: Size
 
         /** 
          * The radius of the shape, as a number if it is a circle, or a size object
          * for ellipses and rounded rectangles.
          */
-        radius: number | Size | null
+        radius: number | Size
 
 
         /** 
@@ -6228,12 +6132,12 @@ declare module paper {
         /** 
          * The width of the size
          */
-        width: number | null
+        width: number
 
         /** 
          * The height of the size
          */
-        height: number | null
+        height: number
 
 
         /** 
@@ -6483,36 +6387,36 @@ declare module paper {
         /** 
          * The width of the stroke.
          */
-        strokeWidth: number | null
+        strokeWidth: number
 
         /** 
          * The shape to be used at the beginning and end of open {@link Path} items,
          * when they have a stroke.
          */
-        strokeCap: string | null
+        strokeCap: string
 
         /** 
          * The shape to be used at the segments and corners of {@link Path} items
          * when they have a stroke.
          */
-        strokeJoin: string | null
+        strokeJoin: string
 
         /** 
          * Specifies whether the stroke is to be drawn taking the current affine
          * transformation into account (the default behavior), or whether it should
          * appear as a non-scaling stroke.
          */
-        strokeScaling: boolean | null
+        strokeScaling: boolean
 
         /** 
          * The dash offset of the stroke.
          */
-        dashOffset: number | null
+        dashOffset: number
 
         /** 
          * Specifies an array containing the dash and gap lengths of the stroke.
          */
-        dashArray: number[] | null
+        dashArray: number[]
 
         /** 
          * The miter limit of the stroke. When two line segments meet at a sharp
@@ -6521,7 +6425,7 @@ declare module paper {
          * the path. The miterLimit imposes a limit on the ratio of the miter length
          * to the {@link #strokeWidth}.
          */
-        miterLimit: number | null
+        miterLimit: number
 
         /** 
          * The fill color.
@@ -6532,7 +6436,7 @@ declare module paper {
          * The fill-rule with which the shape gets filled. Please note that only
          * modern browsers support fill-rules other than `'nonzero'`.
          */
-        fillRule: string | null
+        fillRule: string
 
         /** 
          * The shadow color.
@@ -6542,12 +6446,12 @@ declare module paper {
         /** 
          * The shadow's blur radius.
          */
-        shadowBlur: number | null
+        shadowBlur: number
 
         /** 
          * The shadow's offset.
          */
-        shadowOffset: Point | null
+        shadowOffset: Point
 
         /** 
          * The color the item is highlighted with when selected. If the item does
@@ -6558,28 +6462,28 @@ declare module paper {
         /** 
          * The font-family to be used in text content.
          */
-        fontFamily: string | null
+        fontFamily: string
 
         /** 
          * The font-weight to be used in text content.
          */
-        fontWeight: string | number | null
+        fontWeight: string | number
 
         /** 
          * The font size of text content, as a number in pixels, or as a string with
          * optional units `'px'`, `'pt'` and `'em'`.
          */
-        fontSize: number | string | null
+        fontSize: number | string
 
         /** 
          * The text leading of text content.
          */
-        leading: number | string | null
+        leading: number | string
 
         /** 
          * The justification of text paragraphs.
          */
-        justification: string | null
+        justification: string
 
 
         /** 
@@ -6607,7 +6511,7 @@ declare module paper {
         /** 
          * The item used as the symbol's definition.
          */
-        item: Item | null
+        item: Item
 
 
         /** 
@@ -6647,7 +6551,7 @@ declare module paper {
         /** 
          * The symbol definition that the placed symbol refers to.
          */
-        definition: SymbolDefinition | null
+        definition: SymbolDefinition
 
 
         /** 
@@ -6672,33 +6576,33 @@ declare module paper {
         /** 
          * The text contents of the text item.
          */
-        content: string | null
+        content: string
 
         /** 
          * The font-family to be used in text content.
          */
-        fontFamily: string | null
+        fontFamily: string
 
         /** 
          * The font-weight to be used in text content.
          */
-        fontWeight: string | number | null
+        fontWeight: string | number
 
         /** 
          * The font size of text content, as a number in pixels, or as a string with
          * optional units `'px'`, `'pt'` and `'em'`.
          */
-        fontSize: number | string | null
+        fontSize: number | string
 
         /** 
          * The text leading of text content.
          */
-        leading: number | string | null
+        leading: number | string
 
         /** 
          * The justification of text paragraphs.
          */
-        justification: string | null
+        justification: string
 
 
     }
@@ -6719,16 +6623,16 @@ declare module paper {
          * The minimum distance the mouse has to drag before firing the onMouseDrag
          * event, since the last onMouseDrag event.
          */
-        minDistance: number | null
+        minDistance: number
 
         /** 
          * The maximum distance the mouse has to drag before firing the onMouseDrag
          * event, since the last onMouseDrag event.
          */
-        maxDistance: number | null
+        maxDistance: number
 
         
-        fixedDistance: number | null
+        fixedDistance: number
 
         /** 
          * The function to be called when the mouse button is pushed down. The
@@ -6873,25 +6777,25 @@ declare module paper {
         /** 
          * The type of tool event.
          */
-        type: string | null
+        type: string
 
         /** 
          * The position of the mouse in project coordinates when the event was
          * fired.
          */
-        point: Point | null
+        point: Point
 
         /** 
          * The position of the mouse in project coordinates when the previous
          * event was fired.
          */
-        lastPoint: Point | null
+        lastPoint: Point
 
         /** 
          * The position of the mouse in project coordinates when the mouse button
          * was last clicked.
          */
-        downPoint: Point | null
+        downPoint: Point
 
         /** 
          * The point in the middle between {@link #lastPoint} and
@@ -6899,19 +6803,19 @@ declare module paper {
          * artwork based on the moving direction of the mouse, as returned by
          * {@link #delta}.
          */
-        middlePoint: Point | null
+        middlePoint: Point
 
         /** 
          * The difference between the current position and the last position of the
          * mouse when the event was fired. In case of the mouseup event, the
          * difference to the mousedown position is returned.
          */
-        delta: Point | null
+        delta: Point
 
         /** 
          * The number of times the mouse event was fired.
          */
-        count: number | null
+        count: number
 
         /** 
          * The item at the position of the mouse (if any).
@@ -6920,7 +6824,7 @@ declare module paper {
          * {@link CompoundPath} items, the most top level group or compound path
          * that it is contained within is returned.
          */
-        item: Item | null
+        item: Item
 
 
         /** 
@@ -6999,7 +6903,7 @@ declare module paper {
          * Note that this is `true` by default, except for Node.js, where manual
          * updates make more sense.
          */
-        autoUpdate: boolean | null
+        autoUpdate: boolean
 
         /** 
          * The underlying native element.
@@ -7025,7 +6929,7 @@ declare module paper {
          * The size of the view. Changing the view's size will resize it's
          * underlying element.
          */
-        viewSize: Size | null
+        viewSize: Size
 
         /** 
          * The bounds of the currently visible area in project coordinates.
@@ -7040,20 +6944,20 @@ declare module paper {
         /** 
          * The center of the visible area in project coordinates.
          */
-        center: Point | null
+        center: Point
 
         /** 
          * The view's zoom factor by which the project coordinates are magnified.
          * 
          * @see #scaling
          */
-        zoom: number | null
+        zoom: number
 
         /** 
          * The current rotation angle of the view, as described by its
          * {@link #matrix}.
          */
-        rotation: number | null
+        rotation: number
 
         /** 
          * The current scale factor of the view, as described by its
@@ -7061,13 +6965,13 @@ declare module paper {
          * 
          * @see #zoom
          */
-        scaling: Point | null
+        scaling: Point
 
         /** 
          * The view's transformation matrix, defining the view onto the project's
          * contents (position, zoom level, rotation, etc).
          */
-        matrix: Matrix | null
+        matrix: Matrix
 
         /** 
          * Handler function to be called on each frame of an animation.
@@ -7423,6 +7327,15 @@ declare module paper {
     }
 }
 
-declare module 'paper' {
-    export = paper
+
+declare module 'paper/dist/paper-core'
+{
+    const paperCore: Pick<paper.PaperScope, Exclude<keyof paper.PaperScope, 'PaperScript'>>;
+    export = paperCore
+}
+
+declare module 'paper'
+{
+    const paperFull: paper.PaperScope;
+    export = paperFull
 }
diff --git a/package.json b/package.json
index 71b18964..1c18d7e9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 0fb6283f..16a58d07 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 0fb6283f0955b8ee92fc9ac8838f167ea4a965d2
+Subproject commit 16a58d078c5b72070aa34f1795807361098246d6
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index 1e276564..3d396c63 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit 1e276564106e5a29a6e00115c7e703cfc1fc2b09
+Subproject commit 3d396c63ecbe01d197b6bf3c6129823331f403d4
diff --git a/src/options.js b/src/options.js
index 603cd7ca..e7cb70a0 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.3';
+var version = '0.12.4';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From 00bd25d662dd5f6eb22da707692316dd65eb9757 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Sun, 15 Dec 2019 22:01:14 +0100
Subject: [PATCH 153/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15636 +-------------------------------------
 dist/paper-full.js | 17384 +------------------------------------------
 2 files changed, 2 insertions(+), 33018 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 68dda931..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15635 +0,0 @@
-/*!
- * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sun Dec 15 21:25:00 2019 +0100
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.4",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 64);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index fefe9cf5..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17383 +0,0 @@
-/*!
- * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sun Dec 15 21:25:00 2019 +0100
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.4",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = this._opacity,
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContent || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = this._opacity;
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setCurve: function(curve) {
-		var path = curve._path;
-		this._path = path;
-		this._version = path ? path._version : 0;
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		this._setCurve(segment.getCurve());
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 64);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		for (var i = 1; i < length; i++)
-			addJoin(segments[i], join);
-		if (closed) {
-			addJoin(segments[0], join);
-		} else if (length > 0) {
-			addCap(segments[0], cap);
-			addCap(segments[segments.length - 1], cap);
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._prev)
-					inter = inter._prev;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object' ? svg : new self.DOMParser()
-						.parseFromString(svg, 'image/svg+xml');
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^.*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			sourceMaps = options.sourceMaps,
-			source = options.source || code,
-			lineBreaks = /\r\n|\n|\r/mg,
-			offset = options.offset || 0,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		walkAST(parse(code, {
-			ranges: true,
-			preserveParens: true,
-			sourceType: 'module'
-		}));
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From f00fe1cfd2158b96a804000267a620f2f8a326af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 18 Dec 2019 11:23:15 +0100
Subject: [PATCH 154/181] Improve docs for isBelow() and isAbove()

Closes #1747
---
 src/item/Item.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 5feb9045..2da7d62d 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2977,7 +2977,7 @@ new function() { // Injection scope for hit-test functions shared with project
 
     /**
      * Checks if this item is above the specified item in the stacking order
-     * of the project.
+     * of all its siblings (`parent.children`).
      *
      * @param {Item} item the item to check against
      * @return {Boolean} {@true if it is above the specified item}
@@ -2987,8 +2987,8 @@ new function() { // Injection scope for hit-test functions shared with project
     },
 
     /**
-     * Checks if the item is below the specified item in the stacking order of
-     * the project.
+     * Checks if this item is below the specified item in the stacking order
+     * of all its siblings (`parent.children`).
      *
      * @param {Item} item the item to check against
      * @return {Boolean} {@true if it is below the specified item}

From 2d1856322c5a0336414d195fd74170654942847f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 18 Dec 2019 11:24:28 +0100
Subject: [PATCH 155/181] Adjust authors list

---
 AUTHORS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AUTHORS.md b/AUTHORS.md
index 9ada2ebb..6e6acab8 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -6,7 +6,7 @@
 ## Contributors
 
 - Harikrishnan Gopalakrishnan <hari.exeption@gmail.com>
-- Jan Bösenberg <development@iconexperience.com>
+- Jan Bösenberg <jan.boesenberg@gmail.com>
 - Jt Whissel <jtwhissel@gmail.com>
 - Andrew Roles <jaroles58@gmail.com>
 - Jacob Lites <jnightlight@gmail.com>

From c73e08a481e10243aff26fdfcb7d5669be1d9d99 Mon Sep 17 00:00:00 2001
From: Filprots <filprocenko@gmail.com>
Date: Wed, 18 Dec 2019 13:44:45 +0300
Subject: [PATCH 156/181] Fix new Raster(HTMLCanvasElement) (#1745)

Fix a typo in object.getContext (was object.getContent) accessor to properly identify a canvas
---
 src/item/Raster.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index fee172f5..ed4742f0 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -124,7 +124,7 @@ var Raster = Item.extend(/** @lends Raster# */{
                         ? source
                         : null;
             if (object && object !== Item.NO_INSERT) {
-                if (object.getContent || object.naturalHeight != null) {
+                if (object.getContext || object.naturalHeight != null) {
                     image = object;
                 } else if (object) {
                     // See if the arguments describe the raster size:

From a2069fc73db930dca2e76fc1d96746659ed3b805 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 18 Dec 2019 14:13:15 +0100
Subject: [PATCH 157/181] Revert "Improve docs for isBelow() and isAbove()"

Reverts commit f00fe1cfd2158b96a804000267a620f2f8a326af, which was factually wrong
---
 src/item/Item.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index 2da7d62d..cfe4deae 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2933,7 +2933,7 @@ new function() { // Injection scope for hit-test functions shared with project
      * defined in such a way, e.g. if one is a descendant of the other.
      */
     _getOrder: function(item) {
-        // Private method that produces a list of anchestors, starting with the
+        // Private method that produces a list of ancestors, starting with the
         // root and ending with the actual element as the last entry.
         function getList(item) {
             var list = [];
@@ -2977,7 +2977,7 @@ new function() { // Injection scope for hit-test functions shared with project
 
     /**
      * Checks if this item is above the specified item in the stacking order
-     * of all its siblings (`parent.children`).
+     * of the project.
      *
      * @param {Item} item the item to check against
      * @return {Boolean} {@true if it is above the specified item}
@@ -2987,8 +2987,8 @@ new function() { // Injection scope for hit-test functions shared with project
     },
 
     /**
-     * Checks if this item is below the specified item in the stacking order
-     * of all its siblings (`parent.children`).
+     * Checks if the item is below the specified item in the stacking order of
+     * the project.
      *
      * @param {Item} item the item to check against
      * @return {Boolean} {@true if it is below the specified item}

From efcdd7bda8c4f81e9c913037a4685fcdb63d4d43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Wed, 15 Jan 2020 09:40:49 +0100
Subject: [PATCH 158/181] Handle CurveLocation on path with only one segment

---
 src/path/CurveLocation.js        | 18 ++++++++++++++----
 test/tests/Path_Intersections.js |  2 +-
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index bd84cfd8..19de2c04 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -57,13 +57,16 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
         this._intersection = this._next = this._previous = null;
     },
 
-    _setCurve: function(curve) {
-        var path = curve._path;
+    _setPath: function(path) {
         // We only store the path to verify versions for cached values.
         // To ensure we use the right path (e.g. after splitting), we shall
         // always access the path on the result of getCurve().
         this._path = path;
         this._version = path ? path._version : 0;
+    },
+
+    _setCurve: function(curve) {
+        this._setPath(curve._path);
         this._curve = curve;
         this._segment = null; // To be determined, see #getSegment()
         // Also store references to segment1 and segment2, in case path
@@ -74,7 +77,14 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
     },
 
     _setSegment: function(segment) {
-        this._setCurve(segment.getCurve());
+        var curve = segment.getCurve();
+        if (curve) {
+            this._setCurve(curve);
+        } else {
+            this._setPath(segment._path);
+            this._segment1 = segment;
+            this._segment2 = null;
+        }
         this._segment = segment;
         this._time = segment === this._segment1 ? 0 : 1;
         // To avoid issues with imprecision in getCurve() / trySegment()
@@ -455,7 +465,7 @@ var CurveLocation = Base.extend(/** @lends CurveLocation# */{
                     !end && count ? roots[0] : 1);
             // When no root was found, the full length was calculated. Use a
             // fraction of it. By trial & error, 64 was determined to work well.
-            offsets.push(count ? offset : offset / 64);
+            offsets.push(count ? offset : offset / 32);
         }
 
         function isInRange(angle, min, max) {
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index 2126dac6..eaeb2acd 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -201,7 +201,7 @@ test('#1073#issuecomment-234305530', function() {
         true]);
     testIntersections(path1.getIntersections(path2), [
         { point: { x: 426.61172, y: 448 }, index: 0, time: 0.27769, crossing: true },
-        { point: { x: 376, y: 480 }, index: 1, time: 0, crossing: false },
+        { point: { x: 376, y: 480 }, index: 1, time: 0, crossing: true },
         { point: { x: 343.68011, y: 469.7389 }, index: 1, time: 0.77843, crossing: true },
         { point: { x: 336.40125, y: 463.59875 }, index: 2, time: 0.00608, crossing: true }
     ]);

From 1efa0edb505f679581a4ff8b63914250e6c3398d Mon Sep 17 00:00:00 2001
From: waruyama <43434568+waruyama@users.noreply.github.com>
Date: Mon, 10 Feb 2020 23:49:50 +0100
Subject: [PATCH 159/181] Fix #1769 and add additional test case (#1772)

---
 packages/paper-jsdom        |  2 +-
 packages/paper-jsdom-canvas |  2 +-
 src/path/PathItem.js        |  2 +-
 test/tests/PathItem.js      | 12 ++++++++++++
 4 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 16a58d07..0fb6283f 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 16a58d078c5b72070aa34f1795807361098246d6
+Subproject commit 0fb6283f0955b8ee92fc9ac8838f167ea4a965d2
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index 3d396c63..1e276564 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit 3d396c63ecbe01d197b6bf3c6129823331f403d4
+Subproject commit 1e276564106e5a29a6e00115c7e703cfc1fc2b09
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index 03115233..d11cf738 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -722,7 +722,7 @@ var PathItem = Item.extend(/** @lends PathItem# */{
                 matched = [],
                 count = 0;
             ok = true;
-            var boundsOverlaps = CollisionDetection.findBoundsOverlaps(paths1, paths2, Numerical.GEOMETRIC_EPSILON);      
+            var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);      
             for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
                 var path1 = paths1[i1];
                 ok = false;
diff --git a/test/tests/PathItem.js b/test/tests/PathItem.js
index e92c4a1e..94d5638f 100644
--- a/test/tests/PathItem.js
+++ b/test/tests/PathItem.js
@@ -165,4 +165,16 @@ test('PathItem#compare()', function() {
     equals(function() {
         return circle2.compare(circle);
     }, true, 'Comparing a circle with additional segments with an identical circle should return true.');
+
+    var compoundPath1 = PathItem.create('M50,300l0,-150l50,25l0,-75l200,0l0,200z M100,200l50,0l-50,-25z');
+    var compoundPath2 = PathItem.create('M50,300l0,-150l50,25l0,-75l200,0l0,200z M100,175l0,25l50,0z');
+    var compoundPath3 = PathItem.create('M50,300l0,-150l50,25l0,-75l200,0l0,210z M100,200l50,0l-50,-25z');
+
+    equals(function() {
+        return compoundPath1.compare(compoundPath2);
+    }, true, 'Comparing two compound paths with one child starting at a different point should return true.');
+    equals(function() {
+        return compoundPath1.compare(compoundPath3);
+    }, false, 'Comparing two compound paths with one child having a different shape should return false.');
+    
 });

From 18956805efc679923d1c5b65b3ae9bb130693bcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Tue, 11 Feb 2020 22:51:16 +0100
Subject: [PATCH 160/181] Fix typo in getCrossingSegments()

Closes #1773
---
 src/path/PathItem.Boolean.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index ec64d05e..9eadbf7b 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -943,8 +943,8 @@ PathItem.inject(new function() {
                 collect(inter);
                 // Find the beginning of the linked intersections and loop all
                 // the way back to start, to collect all valid intersections.
-                while (inter && inter._prev)
-                    inter = inter._prev;
+                while (inter && inter._previous)
+                    inter = inter._previous;
                 collect(inter, start);
             }
             return crossings;

From c044b698c6b224c10a7747664b2a4cd00a416a25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=BCrg=20Lehni?= <juerg@scratchdisk.com>
Date: Thu, 13 Feb 2020 17:06:46 +0100
Subject: [PATCH 161/181] Fix comment

---
 src/item/Raster.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index ed4742f0..e40df54d 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -113,7 +113,7 @@ var Raster = Item.extend(/** @lends Raster# */{
         // - A size (Size) describing the canvas that will be  created and an
         //   optional position (Point).
         // If _initialize can set properties through object literal, we're done.
-        // Otherwise we need to check the type of object:       var image,
+        // Otherwise we need to check the type of object:
         if (!this._initialize(source,
                 position !== undefined && Point.read(arguments))) {
             var image,

From 9de1d4a2f36a2a4c62fbf71675bd92fb2b921460 Mon Sep 17 00:00:00 2001
From: Tim Gates <tim.gates@iress.com>
Date: Fri, 10 Apr 2020 07:47:59 +1000
Subject: [PATCH 162/181] docs: Fix simple typo, horziontal -> horizontal

There is a small typo in src/item/Item.js, src/view/View.js.

Should read `horizontal` rather than `horziontal`.
---
 src/item/Item.js | 4 ++--
 src/view/View.js | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index cfe4deae..c33c04c4 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -3465,7 +3465,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#shear
      * @function
-     * @param {Point} shear the horziontal and vertical shear factors as a point
+     * @param {Point} shear the horizontal and vertical shear factors as a point
      * @param {Point} [center={@link Item#position}]
      * @see Matrix#shear(shear[, center])
      */
@@ -3487,7 +3487,7 @@ new function() { // Injection scope for hit-test functions shared with project
      *
      * @name Item#skew
      * @function
-     * @param {Point} skew the horziontal and vertical skew angles in degrees
+     * @param {Point} skew the horizontal and vertical skew angles in degrees
      * @param {Point} [center={@link Item#position}]
      * @see Matrix#shear(skew[, center])
      */
diff --git a/src/view/View.js b/src/view/View.js
index 8a7bc1a7..68b3e244 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -633,7 +633,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#shear
      * @function
-     * @param {Point} shear the horziontal and vertical shear factors as a point
+     * @param {Point} shear the horizontal and vertical shear factors as a point
      * @param {Point} [center={@link View#center}]
      * @see Matrix#shear(shear[, center])
      */
@@ -655,7 +655,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
      *
      * @name View#skew
      * @function
-     * @param {Point} skew the horziontal and vertical skew angles in degrees
+     * @param {Point} skew the horizontal and vertical skew angles in degrees
      * @param {Point} [center={@link View#center}]
      * @see Matrix#shear(skew[, center])
      */

From ccd92acee7cce95d2b7b9971ee60f22f501c24a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 13:10:05 +0200
Subject: [PATCH 163/181] Use paper- prefix in generated view ids

---
 src/view/View.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/view/View.js b/src/view/View.js
index 68b3e244..28a92cfb 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -45,7 +45,7 @@ var View = Base.extend(Emitter, /** @lends View# */{
             // Generate an id for this view / element if it does not have one
             this._id = element.getAttribute('id');
             if (this._id == null)
-                element.setAttribute('id', this._id = 'view-' + View._id++);
+                element.setAttribute('id', this._id = 'paper-view-' + View._id++);
             // Install event handlers
             DomEvent.add(element, this._viewEvents);
             // Borrowed from Hammer.js:

From 5631279f99c521e7ddd5cb00131bdabddbc38979 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 13:40:07 +0200
Subject: [PATCH 164/181] Support SVG strings with leading line-breaks

Closes #1813
---
 src/svg/SvgImport.js    | 14 ++++++++++----
 test/tests/SvgImport.js | 10 ++++++++++
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index 1ad28fb4..b9e8d9ef 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -662,8 +662,12 @@ new function() {
 
         function onLoad(svg) {
             try {
-                var node = typeof svg === 'object' ? svg : new self.DOMParser()
-                        .parseFromString(svg, 'image/svg+xml');
+                var node = typeof svg === 'object'
+                    ? svg
+                    : new self.DOMParser().parseFromString(
+                        svg,
+                        'image/svg+xml'
+                    );
                 if (!node.nodeName) {
                     node = null;
                     throw new Error('Unsupported SVG source: ' + source);
@@ -693,8 +697,10 @@ new function() {
 
         // Have the group not pass on all transformations to its children,
         // as this is how SVG works too.
-        // See if it's a string but handle markup separately
-        if (typeof source === 'string' && !/^.*</.test(source)) {
+        // See if it's a string but handle markup separately, using `[\s\S]` to
+        // also match the first tag if it only starts on the second line in a
+        // multi-line string.
+        if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
             // First see if we're meant to import an element with the given
             // id.
             var node = document.getElementById(source);
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index a7dc2a48..c155d643 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -158,6 +158,16 @@ test('Import SVG switch', function(assert) {
     });
 });
 
+test('Import SVG string with leading line-breaks', function() {
+    var svg = '\n<svg xmlns="http://www.w3.org/2000/svg">\n  <rect fill="red" width="100" height="100"/>\n</svg>\n'
+    var imported = paper.project.importSVG(svg);
+    equals(imported.children.length, 1);
+    equals(imported.firstChild, new Shape.Rectangle({
+        size: [100, 100],
+        fillColor: 'red'
+    }));
+});
+
 function importSVG(assert, url, message, options) {
     var done = assert.async();
     project.importSVG(url, {

From d2f723a0fd1a1cd83b5ffdd3d6ced986061f4321 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 14:08:18 +0200
Subject: [PATCH 165/181] Add option to control operator overloading

---
 src/core/PaperScript.js | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index ca1f393e..b6007d3e 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -346,15 +346,16 @@ Base.exports.PaperScript = function() {
         }
 
         var url = options.url || '',
-            agent = paper.agent,
-            version = agent.versionNumber,
-            offsetCode = false,
             sourceMaps = options.sourceMaps,
+            paperFeatures = options.paperFeatures || {},
             // Include the original code in the sourceMap if there is no linked
             // source file so the debugger can still display it correctly.
             source = options.source || code,
-            lineBreaks = /\r\n|\n|\r/mg,
             offset = options.offset || 0,
+            agent = paper.agent,
+            version = agent.versionNumber,
+            offsetCode = false,
+            lineBreaks = /\r\n|\n|\r/mg,
             map;
         // TODO: Verify these browser versions for source map support, and check
         // other browsers.
@@ -404,12 +405,14 @@ Base.exports.PaperScript = function() {
                 sourcesContent: [source]
             };
         }
-        // Now do the parsing magic
-        walkAST(parse(code, {
-            ranges: true,
-            preserveParens: true,
-            sourceType: 'module'
-        }));
+        if (paperFeatures.operatorOverloading !== false) {
+            // Now do the parsing magic
+            walkAST(parse(code, {
+                ranges: true,
+                preserveParens: true,
+                sourceType: 'module'
+            }));
+        }
         if (map) {
             if (offsetCode) {
                 // Adjust the line offset of the resulting code if required.

From e43f7a8735c9bec00b8b883dc8fd545438e9a90e Mon Sep 17 00:00:00 2001
From: Takahiro Nishino <gv.nishino@gmail.com>
Date: Sat, 23 May 2020 21:43:21 +0900
Subject: [PATCH 166/181] Fix travis build configuration warnings (#1800)

Warnings are reported in
https://travis-ci.org/github/paperjs/paper.js/builds/674265980/config
---
 .travis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 239b6c99..114b3da0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,5 @@
 language: node_js
+os: linux
 # Follow https://github.com/nodejs/LTS to decide when to remove a version
 node_js:
 # Stable version is temporarily disabled due to a bug in resemblejs package with
@@ -7,9 +8,8 @@ node_js:
 - 11
 - 10
 - 8
-sudo: false
 env:
-  matrix:
+  jobs:
   - CXX=g++-4.9
   global:
   - secure: o1fJ/suqcL0aX6PiOmip602dAM6Q6O5oU/BDhSueUOnYknbzWfWGOdsoMun0UYhvvdcXU4sHGH+wm0VeXa2igaxryx36uMxPsXB3mO4sATo/QlWX/r3wLCg2CViXhykE5l2gP45OHh5DJgKWs51cwGLDZ9y9JHlXSP/xIGBNkMGVC7qvyhTfEb0EVvirn9b7Kt8fmD8KYgNDrsmcR3d42f4jitt4Di9LsRyOG+SCXZfI3u831tHo1sgZuGK2rxx2SdEclIblEUCkFHLp0HPjq1+032Cg5D7HNloSCPfoSwcY+rOWHubNXhmXgZHFeSkaVglkdWlDE3NiyjNlYwc4m9zqfCip8jw/jUeSfFVtruncEumGLLBxE/aMBQjAQLTq24juabm3qZNgrNCFeFo+XNyx2Oz1jllGve6Vuu8Qg0wFqE+qlZKnxNbu5/3IOIawOE1uhaOG8oSuvlpQuNrHFIMEfzh2UKPiUHbElUDyoTzHlrhQr7ZSPWPJax4uIPOTscpK4Yks7FBS4I0Vnuhw41f/bVR0kLE9jNAQoUpp47ma9O2Sw9fhOwEiopVrADzARUiy0eNeLx8F2F73L0wyPBOtEL1cfCr5oY+yZ5ZfDYb/L8/GIlbMnljYxVbXesmwd8RFi8X2HUNnEmusjih9oWazVuZpiFfUO0oeu15JTBg=

From 9f249101f0a17181e71db47eb62b7d6f128972e9 Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Sat, 23 May 2020 14:48:39 +0200
Subject: [PATCH 167/181] Update Raster#drawImage documentation (#1784)

Closes #1781
---
 src/item/Raster.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/item/Raster.js b/src/item/Raster.js
index e40df54d..ef37e685 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -561,7 +561,7 @@ var Raster = Item.extend(/** @lends Raster# */{
     /**
      * Draws an image on the raster.
      *
-     * @param {HTMLImageElement|HTMLCanvasElement} image
+     * @param {CanvasImageSource} image
      * @param {Point} point the offset of the image as a point in pixel
      * coordinates
      */

From 8d67d14e980c584fbfa351485ea6ac62f48907bf Mon Sep 17 00:00:00 2001
From: Samuel Asensi <asensi.samuel@gmail.com>
Date: Sat, 23 May 2020 14:54:51 +0200
Subject: [PATCH 168/181] Fix: closed Path with blend mode throw error (#1763)

Closes #1755
---
 src/path/Path.js   | 21 ++++++++++++---------
 test/tests/Path.js | 12 +++++++++++-
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/src/path/Path.js b/src/path/Path.js
index f28d4234..c934462e 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2793,15 +2793,18 @@ statics: {
         }
 
         var length = segments.length - (closed ? 0 : 1);
-        for (var i = 1; i < length; i++)
-            addJoin(segments[i], join);
-        if (closed) {
-            // Go back to the beginning
-            addJoin(segments[0], join);
-        } else if (length > 0) {
-            // Handle caps on open paths
-            addCap(segments[0], cap);
-            addCap(segments[segments.length - 1], cap);
+        if (length > 0) {
+            for (var i = 1; i < length; i++) {
+                addJoin(segments[i], join);
+            }
+            if (closed) {
+                // Go back to the beginning
+                addJoin(segments[0], join);
+            } else {
+                // Handle caps on open paths
+                addCap(segments[0], cap);
+                addCap(segments[segments.length - 1], cap);
+            }
         }
         return bounds;
     },
diff --git a/test/tests/Path.js b/test/tests/Path.js
index 47678d73..3eb8a20b 100644
--- a/test/tests/Path.js
+++ b/test/tests/Path.js
@@ -625,7 +625,7 @@ test('Path#getOffsetsWithTangent()', function() {
     equals(path.getOffsetsWithTangent([1, 0]), [0.25 * length, 0.75 * length], 'should not return duplicates when tangent is at segment point');
     equals(path.getOffsetsWithTangent([1, 1]).length, 2, 'should return 2 values when called on a circle with a diagonal vector');
 });
-  
+
 test('Path#add() with a lot of segments (#1493)', function() {
     var segments = [];
     for (var i = 0; i < 100000; i++) {
@@ -653,3 +653,13 @@ test('Path#arcTo(to, radius, rotation, clockwise, large) when from and to are eq
     path.arcTo(point, new Size(10), 0, true, true);
     expect(0);
 });
+
+test('Path#closed with blend mode', function() {
+    new Path({
+        strokeColor: 'black',
+        blendMode: 'negation',
+        closed: true
+    });
+    view.update();
+    expect(0);
+});

From af509f6431e1f34112a6e1c2cb4a2a4602f83449 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 15:41:18 +0200
Subject: [PATCH 169/181] Clamp opacity values to [0, 1]

Closes #1814
---
 src/item/Item.js   |  2 +-
 src/item/Raster.js |  2 +-
 test/tests/Item.js | 45 ++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 40 insertions(+), 9 deletions(-)

diff --git a/src/item/Item.js b/src/item/Item.js
index c33c04c4..4f2f8140 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -4365,7 +4365,7 @@ new function() { // Injection scope for hit-test functions shared with project
         // Exclude Raster items since they never draw a stroke and handle
         // opacity by themselves (they also don't call _setStyles)
         var blendMode = this._blendMode,
-            opacity = this._opacity,
+            opacity = Numerical.clamp(this._opacity, 0, 1),
             normalBlend = blendMode === 'normal',
             nativeBlend = BlendMode.nativeModes[blendMode],
             // Determine if we can draw directly, or if we need to draw into a
diff --git a/src/item/Raster.js b/src/item/Raster.js
index ef37e685..3b083b53 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -818,7 +818,7 @@ var Raster = Item.extend(/** @lends Raster# */{
         if (element && element.width > 0 && element.height > 0) {
             // Handle opacity for Rasters separately from the rest, since
             // Rasters never draw a stroke. See Item#draw().
-            ctx.globalAlpha = this._opacity;
+            ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
 
             // Call _setStyles() to make sure shadow is drawn (#1437).
             this._setStyles(ctx, param, viewMatrix);
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 0f751996..5cf22cef 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -735,23 +735,54 @@ test('Item#blendMode in a transformed Group', function() {
         blendMode: 'screen'
     });
 
-    var raster = layer.rasterize(72);
+    var raster = layer.rasterize(72, false);
     equals(raster.getPixel(0, 0), new Color(1, 0, 0, 1),
-            'Top left pixel should be red:');
+            'Top left pixel should be red');
     equals(raster.getPixel(50, 50), new Color(1, 1, 0, 1),
-            'Middle center pixel should be yellow:');
+            'Middle center pixel should be yellow');
 
-    raster.remove();
     path2.position = [0, 0];
 
     var group = new Group(path2);
     group.position = [50, 50];
 
-    var raster = layer.rasterize(72);
+    var raster = layer.rasterize(72, false);
     equals(raster.getPixel(0, 0), new Color(1, 0, 0, 1),
-            'Top left pixel should be red:');
+            'Top left pixel should be red');
     equals(raster.getPixel(50, 50), new Color(1, 1, 0, 1),
-            'Middle center pixel should be yellow:');
+            'Middle center pixel should be yellow');
+});
+
+test('Item#opacity', function() {
+    var layer = new Layer();
+    var background = new Path.Rectangle({
+        size: [100, 100],
+        fillColor: 'white'
+    });
+
+    var circle = new Path.Circle({
+        radius: 25,
+        center: [50, 50],
+        fillColor: 'red'
+    });
+
+    const red = new Color(1, 0, 0, 1)
+    const white = new Color(1, 1, 1, 1)
+
+    equals(layer.rasterize(72, false).getPixel(50, 50), red,
+        'Center pixel should be red');
+    circle.opacity = 0;
+    equals(layer.rasterize(72, false).getPixel(50, 50), white,
+        'Center pixel should be white');
+    circle.opacity = -1;
+    equals(layer.rasterize(72, false).getPixel(50, 50), white,
+        'Center pixel should be white');
+    circle.opacity = 1;
+    equals(layer.rasterize(72, false).getPixel(50, 50), red,
+        'Center pixel should be red');
+    circle.opacity = 2;
+    equals(layer.rasterize(72, false).getPixel(50, 50), red,
+        'Center pixel should be red');
 });
 
 test('Item#applyMatrix', function() {

From 7fcee5a911a6c4443aa3204d53046e2d37861589 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 15:51:37 +0200
Subject: [PATCH 170/181] Update CHANGELOG

---
 CHANGELOG.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1e52db29..fb637b83 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # Change Log
 
+## Unreleased
+
+### Changed
+
+- Use `'paper-'` prefix in generated view ids.
+
+### Fixed
+
+- Fix `new Raster(HTMLCanvasElement)` constructor (#1745).
+- Handle `CurveLocation` on paths with only one segment.
+- Fix recently introduced error in `CompoundPath.compare()` (#1769).
+- Clamp opacity values to [0, 1] (#1814).
+- Support closed `Path` items with blend mode and no segments (#1763).
+- Fix error in `getCrossingSegments()` (#1773).
+- SVG Import: Support SVG strings with leading line-breaks (#1813).
+- PaperScript: Add option to control operator overloading.
+- Docs: Improve documentation for `Raster#drawImage(CanvasImageSource)` (#1784).
+
 ## `0.12.4`
 
 ### Added

From c7684bb406f01a0a9ee7f3a59dc8c6c7bc855ee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 16:23:20 +0200
Subject: [PATCH 171/181] Release version 0.12.5

---
 CHANGELOG.md                |     2 +-
 dist/paper-core.js          | 15653 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17404 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |    14 +-
 package.json                |     2 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 8 files changed, 33067 insertions(+), 14 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb637b83..820b337e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## Unreleased
+## `0.12.5`
 
 ### Changed
 
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..ac4c0f92
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15652 @@
+/*!
+ * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 15:51:37 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.5",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..9544dd76
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17403 @@
+/*!
+ * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 15:51:37 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.5",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function walkAST(node, parent) {
+			if (!node)
+				return;
+			for (var key in node) {
+				if (key === 'range' || key === 'loc')
+					continue;
+				var value = node[key];
+				if (Array.isArray(value)) {
+					for (var i = 0, l = value.length; i < l; i++)
+						walkAST(value[i], node);
+				} else if (value && typeof value === 'object') {
+					walkAST(value, node);
+				}
+			}
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			sourceMaps = options.sourceMaps,
+			paperFeatures = options.paperFeatures || {},
+			source = options.source || code,
+			offset = options.offset || 0,
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			lineBreaks = /\r\n|\n|\r/mg,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		if (paperFeatures.operatorOverloading !== false) {
+			walkAST(parse(code, {
+				ranges: true,
+				preserveParens: true,
+				sourceType: 'module'
+			}));
+		}
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index f0cc9398..96b492cf 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.4 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,7 +9,7 @@
  *
  * All rights reserved.
  *
- * Date: Sun Dec 15 21:25:00 2019 +0100
+ * Date: Sat May 23 15:51:37 2020 +0200
  *
  * This is an auto-generated type definition.
  */
@@ -2385,7 +2385,7 @@ declare namespace paper {
          * 
          * @see Matrix#shear(shear[, center])
          * 
-         * @param shear - the horziontal and vertical shear factors as a point
+         * @param shear - the horizontal and vertical shear factors as a point
          */
         shear(shear: Point, center?: Point): void
 
@@ -2406,7 +2406,7 @@ declare namespace paper {
          * 
          * @see Matrix#shear(skew[, center])
          * 
-         * @param skew - the horziontal and vertical skew angles in degrees
+         * @param skew - the horizontal and vertical skew angles in degrees
          */
         skew(skew: Point, center?: Point): void
 
@@ -5412,7 +5412,7 @@ declare namespace paper {
          * @param point - the offset of the image as a point in pixel
          * coordinates
          */
-        drawImage(image: HTMLImageElement | HTMLCanvasElement, point: Point): void
+        drawImage(image: CanvasImageSource, point: Point): void
 
         /** 
          * Calculates the average color of the image within the given path,
@@ -7181,7 +7181,7 @@ declare namespace paper {
          * 
          * @see Matrix#shear(shear[, center])
          * 
-         * @param shear - the horziontal and vertical shear factors as a point
+         * @param shear - the horizontal and vertical shear factors as a point
          */
         shear(shear: Point, center?: Point): void
 
@@ -7200,7 +7200,7 @@ declare namespace paper {
          * 
          * @see Matrix#shear(skew[, center])
          * 
-         * @param skew - the horziontal and vertical skew angles in degrees
+         * @param skew - the horizontal and vertical skew angles in degrees
          */
         skew(skew: Point, center?: Point): void
 
diff --git a/package.json b/package.json
index 1c18d7e9..4c629178 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 0fb6283f..9c3614b4 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 0fb6283f0955b8ee92fc9ac8838f167ea4a965d2
+Subproject commit 9c3614b4ee5627b2e799135d9c3171cc9056fd10
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index 1e276564..77ac8448 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit 1e276564106e5a29a6e00115c7e703cfc1fc2b09
+Subproject commit 77ac84489d65ee693b58a54baeb86e5e8c1379a1
diff --git a/src/options.js b/src/options.js
index e7cb70a0..c983782e 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.4';
+var version = '0.12.5';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From 58dd180deff4444ceeac77c0f55c975f30ae3def Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 16:24:30 +0200
Subject: [PATCH 172/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15653 +-------------------------------------
 dist/paper-full.js | 17404 +------------------------------------------
 2 files changed, 2 insertions(+), 33055 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index ac4c0f92..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15652 +0,0 @@
-/*!
- * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat May 23 15:51:37 2020 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.5",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = Numerical.clamp(this._opacity, 0, 1),
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContext || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setPath: function(path) {
-		this._path = path;
-		this._version = path ? path._version : 0;
-	},
-
-	_setCurve: function(curve) {
-		this._setPath(curve._path);
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		var curve = segment.getCurve();
-		if (curve) {
-			this._setCurve(curve);
-		} else {
-			this._setPath(segment._path);
-			this._segment1 = segment;
-			this._segment2 = null;
-		}
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 32);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		if (length > 0) {
-			for (var i = 1; i < length; i++) {
-				addJoin(segments[i], join);
-			}
-			if (closed) {
-				addJoin(segments[0], join);
-			} else {
-				addCap(segments[0], cap);
-				addCap(segments[segments.length - 1], cap);
-			}
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._previous)
-					inter = inter._previous;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object'
-					? svg
-					: new self.DOMParser().parseFromString(
-						svg,
-						'image/svg+xml'
-					);
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index 9544dd76..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17403 +0,0 @@
-/*!
- * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat May 23 15:51:37 2020 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.5",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = Numerical.clamp(this._opacity, 0, 1),
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContext || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setPath: function(path) {
-		this._path = path;
-		this._version = path ? path._version : 0;
-	},
-
-	_setCurve: function(curve) {
-		this._setPath(curve._path);
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		var curve = segment.getCurve();
-		if (curve) {
-			this._setCurve(curve);
-		} else {
-			this._setPath(segment._path);
-			this._segment1 = segment;
-			this._segment2 = null;
-		}
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 32);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		if (length > 0) {
-			for (var i = 1; i < length; i++) {
-				addJoin(segments[i], join);
-			}
-			if (closed) {
-				addJoin(segments[0], join);
-			} else {
-				addCap(segments[0], cap);
-				addCap(segments[segments.length - 1], cap);
-			}
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._previous)
-					inter = inter._previous;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object'
-					? svg
-					: new self.DOMParser().parseFromString(
-						svg,
-						'image/svg+xml'
-					);
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function walkAST(node, parent) {
-			if (!node)
-				return;
-			for (var key in node) {
-				if (key === 'range' || key === 'loc')
-					continue;
-				var value = node[key];
-				if (Array.isArray(value)) {
-					for (var i = 0, l = value.length; i < l; i++)
-						walkAST(value[i], node);
-				} else if (value && typeof value === 'object') {
-					walkAST(value, node);
-				}
-			}
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			sourceMaps = options.sourceMaps,
-			paperFeatures = options.paperFeatures || {},
-			source = options.source || code,
-			offset = options.offset || 0,
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			lineBreaks = /\r\n|\n|\r/mg,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		if (paperFeatures.operatorOverloading !== false) {
-			walkAST(parse(code, {
-				ranges: true,
-				preserveParens: true,
-				sourceType: 'module'
-			}));
-		}
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From ab481a497b101f83583c9608728a8b393e8b6c42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 20:53:04 +0200
Subject: [PATCH 173/181] Add option to control module exports conversion

---
 src/core/PaperScript.js | 59 ++++++++++++++++++++++++++---------------
 1 file changed, 37 insertions(+), 22 deletions(-)

diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index b6007d3e..791cd798 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -188,27 +188,8 @@ Base.exports.PaperScript = function() {
             code = code.substring(0, start) + str + code.substring(end);
         }
 
-        // Recursively walks the AST and replaces the code of certain nodes
-        function walkAST(node, parent) {
-            if (!node)
-                return;
-            // The easiest way to walk through the whole AST is to simply loop
-            // over each property of the node and filter out fields we don't
-            // need to consider...
-            for (var key in node) {
-                if (key === 'range' || key === 'loc')
-                    continue;
-                var value = node[key];
-                if (Array.isArray(value)) {
-                    for (var i = 0, l = value.length; i < l; i++)
-                        walkAST(value[i], node);
-                } else if (value && typeof value === 'object') {
-                    // We cannot use Base.isPlainObject() for these since
-                    // Acorn.js uses its own internal prototypes now.
-                    walkAST(value, node);
-                }
-            }
-            switch (node.type) {
+        function handleOverloading(node, parent) {
+			switch (node.type) {
             case 'UnaryExpression': // -a
                 if (node.operator in unaryOperators
                         && node.argument.type !== 'Literal') {
@@ -291,6 +272,11 @@ Base.exports.PaperScript = function() {
                     }
                 }
                 break;
+            }
+        }
+
+        function handleExports(node) {
+			switch (node.type) {
             case 'ExportDefaultDeclaration':
                 // Convert `export default` to `module.exports = ` statements:
                 replaceCode({
@@ -328,6 +314,35 @@ Base.exports.PaperScript = function() {
             }
         }
 
+        // Recursively walks the AST and replaces the code of certain nodes
+        function walkAST(node, parent, paperFeatures) {
+            if (node) {
+                // The easiest way to walk through the whole AST is to simply
+                // loop over each property of the node and filter out fields we
+                // don't need to consider...
+                for (var key in node) {
+                    if (key !== 'range' && key !== 'loc') {
+                        var value = node[key];
+                        if (Array.isArray(value)) {
+                            for (var i = 0, l = value.length; i < l; i++) {
+                                walkAST(value[i], node, paperFeatures);
+                            }
+                        } else if (value && typeof value === 'object') {
+                            // Don't use Base.isPlainObject() for these since
+                            // Acorn.js uses its own internal prototypes now.
+                            walkAST(value, node, paperFeatures);
+                        }
+                    }
+                }
+                if (paperFeatures.operatorOverloading !== false) {
+                    handleOverloading(node, parent);
+                }
+                if (paperFeatures.moduleExports !== false) {
+                    handleExports(node);
+                }
+            }
+        }
+
         // Source-map support:
         // Encodes a Variable Length Quantity as a Base64 string.
         // See: https://www.html5rocks.com/en/tutorials/developertools/sourcemaps/
@@ -411,7 +426,7 @@ Base.exports.PaperScript = function() {
                 ranges: true,
                 preserveParens: true,
                 sourceType: 'module'
-            }));
+            }), null, paperFeatures);
         }
         if (map) {
             if (offsetCode) {

From 65886449e1e1d2558f324918084c20ce7c4085e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 21:30:44 +0200
Subject: [PATCH 174/181] Release version 0.12.6

---
 CHANGELOG.md                |    15 +-
 dist/paper-core.js          | 15653 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17419 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |     4 +-
 gulp/tasks/publish.js       |     1 +
 package.json                |     2 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 9 files changed, 33089 insertions(+), 11 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 820b337e..80d810da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,16 @@
 # Change Log
 
+## `0.12.6`
+
+### Added
+
+- PaperScript: Add option to control module exports conversion.
+
 ## `0.12.5`
 
-### Changed
+### Added
 
-- Use `'paper-'` prefix in generated view ids.
+- PaperScript: Add option to control operator overloading.
 
 ### Fixed
 
@@ -15,9 +21,12 @@
 - Support closed `Path` items with blend mode and no segments (#1763).
 - Fix error in `getCrossingSegments()` (#1773).
 - SVG Import: Support SVG strings with leading line-breaks (#1813).
-- PaperScript: Add option to control operator overloading.
 - Docs: Improve documentation for `Raster#drawImage(CanvasImageSource)` (#1784).
 
+### Changed
+
+- Use `'paper-'` prefix in generated view ids.
+
 ## `0.12.4`
 
 ### Added
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..0d7e63d6
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15652 @@
+/*!
+ * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 20:53:04 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.6",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..9c5c580d
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17418 @@
+/*!
+ * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
+ * http://scratchdisk.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 20:53:04 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2019 Juerg Lehni
+ * http://scratchdisk.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.6",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function handleOverloading(node, parent) {
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			}
+		}
+
+		function handleExports(node) {
+			switch (node.type) {
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function walkAST(node, parent, paperFeatures) {
+			if (node) {
+				for (var key in node) {
+					if (key !== 'range' && key !== 'loc') {
+						var value = node[key];
+						if (Array.isArray(value)) {
+							for (var i = 0, l = value.length; i < l; i++) {
+								walkAST(value[i], node, paperFeatures);
+							}
+						} else if (value && typeof value === 'object') {
+							walkAST(value, node, paperFeatures);
+						}
+					}
+				}
+				if (paperFeatures.operatorOverloading !== false) {
+					handleOverloading(node, parent);
+				}
+				if (paperFeatures.moduleExports !== false) {
+					handleExports(node);
+				}
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			sourceMaps = options.sourceMaps,
+			paperFeatures = options.paperFeatures || {},
+			source = options.source || code,
+			offset = options.offset || 0,
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			lineBreaks = /\r\n|\n|\r/mg,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		if (paperFeatures.operatorOverloading !== false) {
+			walkAST(parse(code, {
+				ranges: true,
+				preserveParens: true,
+				sourceType: 'module'
+			}), null, paperFeatures);
+		}
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 96b492cf..758ca847 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,5 +1,5 @@
 /*!
- * Paper.js v0.12.5 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
  * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
@@ -9,7 +9,7 @@
  *
  * All rights reserved.
  *
- * Date: Sat May 23 15:51:37 2020 +0200
+ * Date: Sat May 23 20:53:04 2020 +0200
  *
  * This is an auto-generated type definition.
  */
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 25d37a00..53c77fa1 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -105,6 +105,7 @@ packages.forEach(function(name) {
             .pipe(git.commit(releaseMessage, opts))
             .pipe(git.tag('v' + options.version, releaseMessage, opts))
             .pipe(git.push('origin', 'master', { args: '--tags', cwd: path }))
+            .pipe(shell('echo <%= file.path %>'))
             .pipe(shell('npm publish', opts));
     });
 });
diff --git a/package.json b/package.json
index 4c629178..56d57127 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.5",
+  "version": "0.12.6",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 9c3614b4..59f1653c 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 9c3614b4ee5627b2e799135d9c3171cc9056fd10
+Subproject commit 59f1653c0e24fc69974b636feb2964ac7bc9c9a7
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index 77ac8448..baf33b9a 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit 77ac84489d65ee693b58a54baeb86e5e8c1379a1
+Subproject commit baf33b9a7d95e839d068337929bdc05694b3ab0a
diff --git a/src/options.js b/src/options.js
index c983782e..9d8a8816 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.5';
+var version = '0.12.6';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';

From 357e028e4232d4cabdc928b744f3072fb43be47e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 21:31:49 +0200
Subject: [PATCH 175/181] Switch back to load.js versions on develop branch.

---
 dist/paper-core.js | 15653 +-------------------------------------
 dist/paper-full.js | 17419 +------------------------------------------
 2 files changed, 2 insertions(+), 33070 deletions(-)
 mode change 100644 => 120000 dist/paper-core.js
 mode change 100644 => 120000 dist/paper-full.js

diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 100644
index 0d7e63d6..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1,15652 +0,0 @@
-/*!
- * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat May 23 20:53:04 2020 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.6",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = Numerical.clamp(this._opacity, 0, 1),
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContext || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setPath: function(path) {
-		this._path = path;
-		this._version = path ? path._version : 0;
-	},
-
-	_setCurve: function(curve) {
-		this._setPath(curve._path);
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		var curve = segment.getCurve();
-		if (curve) {
-			this._setCurve(curve);
-		} else {
-			this._setPath(segment._path);
-			this._segment1 = segment;
-			this._segment2 = null;
-		}
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 32);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		if (length > 0) {
-			for (var i = 1; i < length; i++) {
-				addJoin(segments[i], join);
-			}
-			if (closed) {
-				addJoin(segments[0], join);
-			} else {
-				addCap(segments[0], cap);
-				addCap(segments[segments.length - 1], cap);
-			}
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._previous)
-					inter = inter._previous;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object'
-					? svg
-					: new self.DOMParser().parseFromString(
-						svg,
-						'image/svg+xml'
-					);
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 100644
index 9c5c580d..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1,17418 +0,0 @@
-/*!
- * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
- * http://paperjs.org/
- *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
- *
- * Distributed under the MIT license. See LICENSE file for details.
- *
- * All rights reserved.
- *
- * Date: Sat May 23 20:53:04 2020 +0200
- *
- ***
- *
- * Straps.js - Class inheritance library with support for bean-style accessors
- *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
- *
- * Distributed under the MIT license.
- *
- ***
- *
- * Acorn.js
- * https://marijnhaverbeke.nl/acorn/
- *
- * Acorn is a tiny, fast JavaScript parser written in JavaScript,
- * created by Marijn Haverbeke and released under an MIT license.
- *
- */
-
-var paper = function(self, undefined) {
-
-self = self || require('./node/self.js');
-var window = self.window,
-	document = self.document;
-
-var Base = new function() {
-	var hidden = /^(statics|enumerable|beans|preserve)$/,
-		array = [],
-		slice = array.slice,
-		create = Object.create,
-		describe = Object.getOwnPropertyDescriptor,
-		define = Object.defineProperty,
-
-		forEach = array.forEach || function(iter, bind) {
-			for (var i = 0, l = this.length; i < l; i++) {
-				iter.call(bind, this[i], i, this);
-			}
-		},
-
-		forIn = function(iter, bind) {
-			for (var i in this) {
-				if (this.hasOwnProperty(i))
-					iter.call(bind, this[i], i, this);
-			}
-		},
-
-		set = Object.assign || function(dst) {
-			for (var i = 1, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				for (var key in src) {
-					if (src.hasOwnProperty(key))
-						dst[key] = src[key];
-				}
-			}
-			return dst;
-		},
-
-		each = function(obj, iter, bind) {
-			if (obj) {
-				var desc = describe(obj, 'length');
-				(desc && typeof desc.value === 'number' ? forEach : forIn)
-					.call(obj, iter, bind = bind || obj);
-			}
-			return bind;
-		};
-
-	function inject(dest, src, enumerable, beans, preserve) {
-		var beansNames = {};
-
-		function field(name, val) {
-			val = val || (val = describe(src, name))
-					&& (val.get ? val : val.value);
-			if (typeof val === 'string' && val[0] === '#')
-				val = dest[val.substring(1)] || val;
-			var isFunc = typeof val === 'function',
-				res = val,
-				prev = preserve || isFunc && !val.base
-						? (val && val.get ? name in dest : dest[name])
-						: null,
-				bean;
-			if (!preserve || !prev) {
-				if (isFunc && prev)
-					val.base = prev;
-				if (isFunc && beans !== false
-						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
-					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
-				if (!res || isFunc || !res.get || typeof res.get !== 'function'
-						|| !Base.isPlainObject(res)) {
-					res = { value: res, writable: true };
-				}
-				if ((describe(dest, name)
-						|| { configurable: true }).configurable) {
-					res.configurable = true;
-					res.enumerable = enumerable != null ? enumerable : !bean;
-				}
-				define(dest, name, res);
-			}
-		}
-		if (src) {
-			for (var name in src) {
-				if (src.hasOwnProperty(name) && !hidden.test(name))
-					field(name);
-			}
-			for (var name in beansNames) {
-				var part = beansNames[name],
-					set = dest['set' + part],
-					get = dest['get' + part] || set && dest['is' + part];
-				if (get && (beans === true || get.length === 0))
-					field(name, { get: get, set: set });
-			}
-		}
-		return dest;
-	}
-
-	function Base() {
-		for (var i = 0, l = arguments.length; i < l; i++) {
-			var src = arguments[i];
-			if (src)
-				set(this, src);
-		}
-		return this;
-	}
-
-	return inject(Base, {
-		inject: function(src) {
-			if (src) {
-				var statics = src.statics === true ? src : src.statics,
-					beans = src.beans,
-					preserve = src.preserve;
-				if (statics !== src)
-					inject(this.prototype, src, src.enumerable, beans, preserve);
-				inject(this, statics, null, beans, preserve);
-			}
-			for (var i = 1, l = arguments.length; i < l; i++)
-				this.inject(arguments[i]);
-			return this;
-		},
-
-		extend: function() {
-			var base = this,
-				ctor,
-				proto;
-			for (var i = 0, obj, l = arguments.length;
-					i < l && !(ctor && proto); i++) {
-				obj = arguments[i];
-				ctor = ctor || obj.initialize;
-				proto = proto || obj.prototype;
-			}
-			ctor = ctor || function() {
-				base.apply(this, arguments);
-			};
-			proto = ctor.prototype = proto || create(this.prototype);
-			define(proto, 'constructor',
-					{ value: ctor, writable: true, configurable: true });
-			inject(ctor, this);
-			if (arguments.length)
-				this.inject.apply(ctor, arguments);
-			ctor.base = base;
-			return ctor;
-		}
-	}).inject({
-		enumerable: false,
-
-		initialize: Base,
-
-		set: Base,
-
-		inject: function() {
-			for (var i = 0, l = arguments.length; i < l; i++) {
-				var src = arguments[i];
-				if (src) {
-					inject(this, src, src.enumerable, src.beans, src.preserve);
-				}
-			}
-			return this;
-		},
-
-		extend: function() {
-			var res = create(this);
-			return res.inject.apply(res, arguments);
-		},
-
-		each: function(iter, bind) {
-			return each(this, iter, bind);
-		},
-
-		clone: function() {
-			return new this.constructor(this);
-		},
-
-		statics: {
-			set: set,
-			each: each,
-			create: create,
-			define: define,
-			describe: describe,
-
-			clone: function(obj) {
-				return set(new obj.constructor(), obj);
-			},
-
-			isPlainObject: function(obj) {
-				var ctor = obj != null && obj.constructor;
-				return ctor && (ctor === Object || ctor === Base
-						|| ctor.name === 'Object');
-			},
-
-			pick: function(a, b) {
-				return a !== undefined ? a : b;
-			},
-
-			slice: function(list, begin, end) {
-				return slice.call(list, begin, end);
-			}
-		}
-	});
-};
-
-if (typeof module !== 'undefined')
-	module.exports = Base;
-
-Base.inject({
-	enumerable: false,
-
-	toString: function() {
-		return this._id != null
-			?  (this._class || 'Object') + (this._name
-				? " '" + this._name + "'"
-				: ' @' + this._id)
-			: '{ ' + Base.each(this, function(value, key) {
-				if (!/^_/.test(key)) {
-					var type = typeof value;
-					this.push(key + ': ' + (type === 'number'
-							? Formatter.instance.number(value)
-							: type === 'string' ? "'" + value + "'" : value));
-				}
-			}, []).join(', ') + ' }';
-	},
-
-	getClassName: function() {
-		return this._class || '';
-	},
-
-	importJSON: function(json) {
-		return Base.importJSON(json, this);
-	},
-
-	exportJSON: function(options) {
-		return Base.exportJSON(this, options);
-	},
-
-	toJSON: function() {
-		return Base.serialize(this);
-	},
-
-	set: function(props, exclude) {
-		if (props)
-			Base.filter(this, props, exclude, this._prioritize);
-		return this;
-	}
-}, {
-
-beans: false,
-statics: {
-	exports: {},
-
-	extend: function extend() {
-		var res = extend.base.apply(this, arguments),
-			name = res.prototype._class;
-		if (name && !Base.exports[name])
-			Base.exports[name] = res;
-		return res;
-	},
-
-	equals: function(obj1, obj2) {
-		if (obj1 === obj2)
-			return true;
-		if (obj1 && obj1.equals)
-			return obj1.equals(obj2);
-		if (obj2 && obj2.equals)
-			return obj2.equals(obj1);
-		if (obj1 && obj2
-				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				var length = obj1.length;
-				if (length !== obj2.length)
-					return false;
-				while (length--) {
-					if (!Base.equals(obj1[length], obj2[length]))
-						return false;
-				}
-			} else {
-				var keys = Object.keys(obj1),
-					length = keys.length;
-				if (length !== Object.keys(obj2).length)
-					return false;
-				while (length--) {
-					var key = keys[length];
-					if (!(obj2.hasOwnProperty(key)
-							&& Base.equals(obj1[key], obj2[key])))
-						return false;
-				}
-			}
-			return true;
-		}
-		return false;
-	},
-
-	read: function(list, start, options, amount) {
-		if (this === Base) {
-			var value = this.peek(list, start);
-			list.__index++;
-			return value;
-		}
-		var proto = this.prototype,
-			readIndex = proto._readIndex,
-			begin = start || readIndex && list.__index || 0,
-			length = list.length,
-			obj = list[begin];
-		amount = amount || length - begin;
-		if (obj instanceof this
-			|| options && options.readNull && obj == null && amount <= 1) {
-			if (readIndex)
-				list.__index = begin + 1;
-			return obj && options && options.clone ? obj.clone() : obj;
-		}
-		obj = Base.create(proto);
-		if (readIndex)
-			obj.__read = true;
-		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
-				? Base.slice(list, begin, begin + amount)
-				: list) || obj;
-		if (readIndex) {
-			list.__index = begin + obj.__read;
-			var filtered = obj.__filtered;
-			if (filtered) {
-				list.__filtered = filtered;
-				obj.__filtered = undefined;
-			}
-			obj.__read = undefined;
-		}
-		return obj;
-	},
-
-	peek: function(list, start) {
-		return list[list.__index = start || list.__index || 0];
-	},
-
-	remain: function(list) {
-		return list.length - (list.__index || 0);
-	},
-
-	readList: function(list, start, options, amount) {
-		var res = [],
-			entry,
-			begin = start || 0,
-			end = amount ? begin + amount : list.length;
-		for (var i = begin; i < end; i++) {
-			res.push(Array.isArray(entry = list[i])
-					? this.read(entry, 0, options)
-					: this.read(list, i, options, 1));
-		}
-		return res;
-	},
-
-	readNamed: function(list, name, start, options, amount) {
-		var value = this.getNamed(list, name),
-			hasValue = value !== undefined;
-		if (hasValue) {
-			var filtered = list.__filtered;
-			if (!filtered) {
-				var source = this.getSource(list);
-				filtered = list.__filtered = Base.create(source);
-				filtered.__unfiltered = source;
-			}
-			filtered[name] = undefined;
-		}
-		return this.read(hasValue ? [value] : list, start, options, amount);
-	},
-
-	readSupported: function(list, dest) {
-		var source = this.getSource(list),
-			that = this,
-			read = false;
-		if (source) {
-			Object.keys(source).forEach(function(key) {
-				if (key in dest) {
-					var value = that.readNamed(list, key);
-					if (value !== undefined) {
-						dest[key] = value;
-					}
-					read = true;
-				}
-			});
-		}
-		return read;
-	},
-
-	getSource: function(list) {
-		var source = list.__source;
-		if (source === undefined) {
-			var arg = list.length === 1 && list[0];
-			source = list.__source = arg && Base.isPlainObject(arg)
-				? arg : null;
-		}
-		return source;
-	},
-
-	getNamed: function(list, name) {
-		var source = this.getSource(list);
-		if (source) {
-			return name ? source[name] : list.__filtered || source;
-		}
-	},
-
-	hasNamed: function(list, name) {
-		return !!this.getNamed(list, name);
-	},
-
-	filter: function(dest, source, exclude, prioritize) {
-		var processed;
-
-		function handleKey(key) {
-			if (!(exclude && key in exclude) &&
-				!(processed && key in processed)) {
-				var value = source[key];
-				if (value !== undefined)
-					dest[key] = value;
-			}
-		}
-
-		if (prioritize) {
-			var keys = {};
-			for (var i = 0, key, l = prioritize.length; i < l; i++) {
-				if ((key = prioritize[i]) in source) {
-					handleKey(key);
-					keys[key] = true;
-				}
-			}
-			processed = keys;
-		}
-
-		Object.keys(source.__unfiltered || source).forEach(handleKey);
-		return dest;
-	},
-
-	isPlainValue: function(obj, asString) {
-		return Base.isPlainObject(obj) || Array.isArray(obj)
-				|| asString && typeof obj === 'string';
-	},
-
-	serialize: function(obj, options, compact, dictionary) {
-		options = options || {};
-
-		var isRoot = !dictionary,
-			res;
-		if (isRoot) {
-			options.formatter = new Formatter(options.precision);
-			dictionary = {
-				length: 0,
-				definitions: {},
-				references: {},
-				add: function(item, create) {
-					var id = '#' + item._id,
-						ref = this.references[id];
-					if (!ref) {
-						this.length++;
-						var res = create.call(item),
-							name = item._class;
-						if (name && res[0] !== name)
-							res.unshift(name);
-						this.definitions[id] = res;
-						ref = this.references[id] = [id];
-					}
-					return ref;
-				}
-			};
-		}
-		if (obj && obj._serialize) {
-			res = obj._serialize(options, dictionary);
-			var name = obj._class;
-			if (name && !obj._compactSerialize && (isRoot || !compact)
-					&& res[0] !== name) {
-				res.unshift(name);
-			}
-		} else if (Array.isArray(obj)) {
-			res = [];
-			for (var i = 0, l = obj.length; i < l; i++)
-				res[i] = Base.serialize(obj[i], options, compact, dictionary);
-		} else if (Base.isPlainObject(obj)) {
-			res = {};
-			var keys = Object.keys(obj);
-			for (var i = 0, l = keys.length; i < l; i++) {
-				var key = keys[i];
-				res[key] = Base.serialize(obj[key], options, compact,
-						dictionary);
-			}
-		} else if (typeof obj === 'number') {
-			res = options.formatter.number(obj, options.precision);
-		} else {
-			res = obj;
-		}
-		return isRoot && dictionary.length > 0
-				? [['dictionary', dictionary.definitions], res]
-				: res;
-	},
-
-	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
-		var res = json,
-			isFirst = !_data,
-			hasDictionary = isFirst && json && json.length
-				&& json[0][0] === 'dictionary';
-		_data = _data || {};
-		if (Array.isArray(json)) {
-			var type = json[0],
-				isDictionary = type === 'dictionary';
-			if (json.length == 1 && /^#/.test(type)) {
-				return _data.dictionary[type];
-			}
-			type = Base.exports[type];
-			res = [];
-			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
-				res.push(Base.deserialize(json[i], create, _data,
-						isDictionary, hasDictionary));
-			}
-			if (type) {
-				var args = res;
-				if (create) {
-					res = create(type, args, isFirst || _isRoot);
-				} else {
-					res = new type(args);
-				}
-			}
-		} else if (Base.isPlainObject(json)) {
-			res = {};
-			if (_setDictionary)
-				_data.dictionary = res;
-			for (var key in json)
-				res[key] = Base.deserialize(json[key], create, _data);
-		}
-		return hasDictionary ? res[1] : res;
-	},
-
-	exportJSON: function(obj, options) {
-		var json = Base.serialize(obj, options);
-		return options && options.asString == false
-				? json
-				: JSON.stringify(json);
-	},
-
-	importJSON: function(json, target) {
-		return Base.deserialize(
-				typeof json === 'string' ? JSON.parse(json) : json,
-				function(ctor, args, isRoot) {
-					var useTarget = isRoot && target
-							&& target.constructor === ctor,
-						obj = useTarget ? target
-							: Base.create(ctor.prototype);
-					if (args.length === 1 && obj instanceof Item
-							&& (useTarget || !(obj instanceof Layer))) {
-						var arg = args[0];
-						if (Base.isPlainObject(arg)) {
-							arg.insert = false;
-							if (useTarget) {
-								args = args.concat([{ insert: true }]);
-							}
-						}
-					}
-					(useTarget ? obj.set : ctor).apply(obj, args);
-					if (useTarget)
-						target = null;
-					return obj;
-				});
-	},
-
-	push: function(list, items) {
-		var itemsLength = items.length;
-		if (itemsLength < 4096) {
-			list.push.apply(list, items);
-		} else {
-			var startLength = list.length;
-			list.length += itemsLength;
-			for (var i = 0; i < itemsLength; i++) {
-				list[startLength + i] = items[i];
-			}
-		}
-		return list;
-	},
-
-	splice: function(list, items, index, remove) {
-		var amount = items && items.length,
-			append = index === undefined;
-		index = append ? list.length : index;
-		if (index > list.length)
-			index = list.length;
-		for (var i = 0; i < amount; i++)
-			items[i]._index = index + i;
-		if (append) {
-			Base.push(list, items);
-			return [];
-		} else {
-			var args = [index, remove];
-			if (items)
-				Base.push(args, items);
-			var removed = list.splice.apply(list, args);
-			for (var i = 0, l = removed.length; i < l; i++)
-				removed[i]._index = undefined;
-			for (var i = index + amount, l = list.length; i < l; i++)
-				list[i]._index = i;
-			return removed;
-		}
-	},
-
-	capitalize: function(str) {
-		return str.replace(/\b[a-z]/g, function(match) {
-			return match.toUpperCase();
-		});
-	},
-
-	camelize: function(str) {
-		return str.replace(/-(.)/g, function(match, chr) {
-			return chr.toUpperCase();
-		});
-	},
-
-	hyphenate: function(str) {
-		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-	}
-}});
-
-var Emitter = {
-	on: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.on(key, value);
-			}, this);
-		} else {
-			var types = this._eventTypes,
-				entry = types && types[type],
-				handlers = this._callbacks = this._callbacks || {};
-			handlers = handlers[type] = handlers[type] || [];
-			if (handlers.indexOf(func) === -1) {
-				handlers.push(func);
-				if (entry && entry.install && handlers.length === 1)
-					entry.install.call(this, type);
-			}
-		}
-		return this;
-	},
-
-	off: function(type, func) {
-		if (typeof type !== 'string') {
-			Base.each(type, function(value, key) {
-				this.off(key, value);
-			}, this);
-			return;
-		}
-		var types = this._eventTypes,
-			entry = types && types[type],
-			handlers = this._callbacks && this._callbacks[type],
-			index;
-		if (handlers) {
-			if (!func || (index = handlers.indexOf(func)) !== -1
-					&& handlers.length === 1) {
-				if (entry && entry.uninstall)
-					entry.uninstall.call(this, type);
-				delete this._callbacks[type];
-			} else if (index !== -1) {
-				handlers.splice(index, 1);
-			}
-		}
-		return this;
-	},
-
-	once: function(type, func) {
-		return this.on(type, function handler() {
-			func.apply(this, arguments);
-			this.off(type, handler);
-		});
-	},
-
-	emit: function(type, event) {
-		var handlers = this._callbacks && this._callbacks[type];
-		if (!handlers)
-			return false;
-		var args = Base.slice(arguments, 1),
-			setTarget = event && event.target && !event.currentTarget;
-		handlers = handlers.slice();
-		if (setTarget)
-			event.currentTarget = this;
-		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) == false) {
-				if (event && event.stop)
-					event.stop();
-				break;
-		   }
-		}
-		if (setTarget)
-			delete event.currentTarget;
-		return true;
-	},
-
-	responds: function(type) {
-		return !!(this._callbacks && this._callbacks[type]);
-	},
-
-	attach: '#on',
-	detach: '#off',
-	fire: '#emit',
-
-	_installEvents: function(install) {
-		var types = this._eventTypes,
-			handlers = this._callbacks,
-			key = install ? 'install' : 'uninstall';
-		if (types) {
-			for (var type in handlers) {
-				if (handlers[type].length > 0) {
-					var entry = types[type],
-						func = entry && entry[key];
-					if (func)
-						func.call(this, type);
-				}
-			}
-		}
-	},
-
-	statics: {
-		inject: function inject(src) {
-			var events = src._events;
-			if (events) {
-				var types = {};
-				Base.each(events, function(entry, key) {
-					var isString = typeof entry === 'string',
-						name = isString ? entry : key,
-						part = Base.capitalize(name),
-						type = name.substring(2).toLowerCase();
-					types[type] = isString ? {} : entry;
-					name = '_' + name;
-					src['get' + part] = function() {
-						return this[name];
-					};
-					src['set' + part] = function(func) {
-						var prev = this[name];
-						if (prev)
-							this.off(type, prev);
-						if (func)
-							this.on(type, func);
-						this[name] = func;
-					};
-				});
-				src._eventTypes = types;
-			}
-			return inject.base.apply(this, arguments);
-		}
-	}
-};
-
-var PaperScope = Base.extend({
-	_class: 'PaperScope',
-
-	initialize: function PaperScope() {
-		paper = this;
-		this.settings = new Base({
-			applyMatrix: true,
-			insertItems: true,
-			handleSize: 4,
-			hitTolerance: 0
-		});
-		this.project = null;
-		this.projects = [];
-		this.tools = [];
-		this._id = PaperScope._id++;
-		PaperScope._scopes[this._id] = this;
-		var proto = PaperScope.prototype;
-		if (!this.support) {
-			var ctx = CanvasProvider.getContext(1, 1) || {};
-			proto.support = {
-				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
-				nativeBlendModes: BlendMode.nativeModes
-			};
-			CanvasProvider.release(ctx);
-		}
-		if (!this.agent) {
-			var user = self.navigator.userAgent.toLowerCase(),
-				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
-				platform = os === 'darwin' ? 'mac' : os,
-				agent = proto.agent = proto.browser = { platform: platform };
-			if (platform)
-				agent[platform] = true;
-			user.replace(
-				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
-				function(match, n, v1, v2, rv) {
-					if (!agent.chrome) {
-						var v = n === 'opera' ? v2 :
-								/^(node|trident)$/.test(n) ? rv : v1;
-						agent.version = v;
-						agent.versionNumber = parseFloat(v);
-						n = { trident: 'msie', jsdom: 'node' }[n] || n;
-						agent.name = n;
-						agent[n] = true;
-					}
-				}
-			);
-			if (agent.chrome)
-				delete agent.webkit;
-			if (agent.atom)
-				delete agent.chrome;
-		}
-	},
-
-	version: "0.12.6",
-
-	getView: function() {
-		var project = this.project;
-		return project && project._view;
-	},
-
-	getPaper: function() {
-		return this;
-	},
-
-	execute: function(code, options) {
-			var exports = paper.PaperScript.execute(code, this, options);
-			View.updateFocus();
-			return exports;
-	},
-
-	install: function(scope) {
-		var that = this;
-		Base.each(['project', 'view', 'tool'], function(key) {
-			Base.define(scope, key, {
-				configurable: true,
-				get: function() {
-					return that[key];
-				}
-			});
-		});
-		for (var key in this)
-			if (!/^_/.test(key) && this[key])
-				scope[key] = this[key];
-	},
-
-	setup: function(element) {
-		paper = this;
-		this.project = new Project(element);
-		return this;
-	},
-
-	createCanvas: function(width, height) {
-		return CanvasProvider.getCanvas(width, height);
-	},
-
-	activate: function() {
-		paper = this;
-	},
-
-	clear: function() {
-		var projects = this.projects,
-			tools = this.tools;
-		for (var i = projects.length - 1; i >= 0; i--)
-			projects[i].remove();
-		for (var i = tools.length - 1; i >= 0; i--)
-			tools[i].remove();
-	},
-
-	remove: function() {
-		this.clear();
-		delete PaperScope._scopes[this._id];
-	},
-
-	statics: new function() {
-		function handleAttribute(name) {
-			name += 'Attribute';
-			return function(el, attr) {
-				return el[name](attr) || el[name]('data-paper-' + attr);
-			};
-		}
-
-		return {
-			_scopes: {},
-			_id: 0,
-
-			get: function(id) {
-				return this._scopes[id] || null;
-			},
-
-			getAttribute: handleAttribute('get'),
-			hasAttribute: handleAttribute('has')
-		};
-	}
-});
-
-var PaperScopeItem = Base.extend(Emitter, {
-
-	initialize: function(activate) {
-		this._scope = paper;
-		this._index = this._scope[this._list].push(this) - 1;
-		if (activate || !this._scope[this._reference])
-			this.activate();
-	},
-
-	activate: function() {
-		if (!this._scope)
-			return false;
-		var prev = this._scope[this._reference];
-		if (prev && prev !== this)
-			prev.emit('deactivate');
-		this._scope[this._reference] = this;
-		this.emit('activate', prev);
-		return true;
-	},
-
-	isActive: function() {
-		return this._scope[this._reference] === this;
-	},
-
-	remove: function() {
-		if (this._index == null)
-			return false;
-		Base.splice(this._scope[this._list], null, this._index, 1);
-		if (this._scope[this._reference] == this)
-			this._scope[this._reference] = null;
-		this._scope = null;
-		return true;
-	},
-
-	getView: function() {
-		return this._scope.getView();
-	}
-});
-
-var CollisionDetection = {
-	findItemBoundsCollisions: function(items1, items2, tolerance) {
-		function getBounds(items) {
-			var bounds = new Array(items.length);
-			for (var i = 0; i < items.length; i++) {
-				var rect = items[i].getBounds();
-				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(items1),
-			bounds2 = !items2 || items2 === items1
-				? bounds1
-				: getBounds(items2);
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
-		function getBounds(curves) {
-			var min = Math.min,
-				max = Math.max,
-				bounds = new Array(curves.length);
-			for (var i = 0; i < curves.length; i++) {
-				var v = curves[i];
-				bounds[i] = [
-					min(v[0], v[2], v[4], v[6]),
-					min(v[1], v[3], v[5], v[7]),
-					max(v[0], v[2], v[4], v[6]),
-					max(v[1], v[3], v[5], v[7])
-				];
-			}
-			return bounds;
-		}
-
-		var bounds1 = getBounds(curves1),
-			bounds2 = !curves2 || curves2 === curves1
-				? bounds1
-				: getBounds(curves2);
-		if (bothAxis) {
-			var hor = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, false, true),
-				ver = this.findBoundsCollisions(
-					bounds1, bounds2, tolerance || 0, true, true),
-				list = [];
-			for (var i = 0, l = hor.length; i < l; i++) {
-				list[i] = { hor: hor[i], ver: ver[i] };
-			}
-			return list;
-		}
-		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
-	},
-
-	findBoundsCollisions: function(boundsA, boundsB, tolerance,
-		sweepVertical, onlySweepAxisCollisions) {
-		var self = !boundsB || boundsA === boundsB,
-			allBounds = self ? boundsA : boundsA.concat(boundsB),
-			lengthA = boundsA.length,
-			lengthAll = allBounds.length;
-
-		function binarySearch(indices, coord, value) {
-			var lo = 0,
-				hi = indices.length;
-			while (lo < hi) {
-				var mid = (hi + lo) >>> 1;
-				if (allBounds[indices[mid]][coord] < value) {
-					lo = mid + 1;
-				} else {
-					hi = mid;
-				}
-			}
-			return lo - 1;
-		}
-
-		var pri0 = sweepVertical ? 1 : 0,
-			pri1 = pri0 + 2,
-			sec0 = sweepVertical ? 0 : 1,
-			sec1 = sec0 + 2;
-		var allIndicesByPri0 = new Array(lengthAll);
-		for (var i = 0; i < lengthAll; i++) {
-			allIndicesByPri0[i] = i;
-		}
-		allIndicesByPri0.sort(function(i1, i2) {
-			return allBounds[i1][pri0] - allBounds[i2][pri0];
-		});
-		var activeIndicesByPri1 = [],
-			allCollisions = new Array(lengthA);
-		for (var i = 0; i < lengthAll; i++) {
-			var curIndex = allIndicesByPri0[i],
-				curBounds = allBounds[curIndex],
-				origIndex = self ? curIndex : curIndex - lengthA,
-				isCurrentA = curIndex < lengthA,
-				isCurrentB = self || !isCurrentA,
-				curCollisions = isCurrentA ? [] : null;
-			if (activeIndicesByPri1.length) {
-				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
-						curBounds[pri0] - tolerance) + 1;
-				activeIndicesByPri1.splice(0, pruneCount);
-				if (self && onlySweepAxisCollisions) {
-					curCollisions = curCollisions.concat(activeIndicesByPri1);
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j];
-						allCollisions[activeIndex].push(origIndex);
-					}
-				} else {
-					var curSec1 = curBounds[sec1],
-						curSec0 = curBounds[sec0];
-					for (var j = 0; j < activeIndicesByPri1.length; j++) {
-						var activeIndex = activeIndicesByPri1[j],
-							activeBounds = allBounds[activeIndex],
-							isActiveA = activeIndex < lengthA,
-							isActiveB = self || activeIndex >= lengthA;
-
-						if (
-							onlySweepAxisCollisions ||
-							(
-								isCurrentA && isActiveB ||
-								isCurrentB && isActiveA
-							) && (
-								curSec1 >= activeBounds[sec0] - tolerance &&
-								curSec0 <= activeBounds[sec1] + tolerance
-							)
-						) {
-							if (isCurrentA && isActiveB) {
-								curCollisions.push(
-									self ? activeIndex : activeIndex - lengthA);
-							}
-							if (isCurrentB && isActiveA) {
-								allCollisions[activeIndex].push(origIndex);
-							}
-						}
-					}
-				}
-			}
-			if (isCurrentA) {
-				if (boundsA === boundsB) {
-					curCollisions.push(curIndex);
-				}
-				allCollisions[curIndex] = curCollisions;
-			}
-			if (activeIndicesByPri1.length) {
-				var curPri1 = curBounds[pri1],
-					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
-				activeIndicesByPri1.splice(index + 1, 0, curIndex);
-			} else {
-				activeIndicesByPri1.push(curIndex);
-			}
-		}
-		for (var i = 0; i < allCollisions.length; i++) {
-			var collisions = allCollisions[i];
-			if (collisions) {
-				collisions.sort(function(i1, i2) { return i1 - i2; });
-			}
-		}
-		return allCollisions;
-	}
-};
-
-var Formatter = Base.extend({
-	initialize: function(precision) {
-		this.precision = Base.pick(precision, 5);
-		this.multiplier = Math.pow(10, this.precision);
-	},
-
-	number: function(val) {
-		return this.precision < 16
-				? Math.round(val * this.multiplier) / this.multiplier : val;
-	},
-
-	pair: function(val1, val2, separator) {
-		return this.number(val1) + (separator || ',') + this.number(val2);
-	},
-
-	point: function(val, separator) {
-		return this.number(val.x) + (separator || ',') + this.number(val.y);
-	},
-
-	size: function(val, separator) {
-		return this.number(val.width) + (separator || ',')
-				+ this.number(val.height);
-	},
-
-	rectangle: function(val, separator) {
-		return this.point(val, separator) + (separator || ',')
-				+ this.size(val, separator);
-	}
-});
-
-Formatter.instance = new Formatter();
-
-var Numerical = new function() {
-
-	var abscissas = [
-		[  0.5773502691896257645091488],
-		[0,0.7745966692414833770358531],
-		[  0.3399810435848562648026658,0.8611363115940525752239465],
-		[0,0.5384693101056830910363144,0.9061798459386639927976269],
-		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
-		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
-		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
-		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
-		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
-		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
-		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
-		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
-		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
-		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
-		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
-	];
-
-	var weights = [
-		[1],
-		[0.8888888888888888888888889,0.5555555555555555555555556],
-		[0.6521451548625461426269361,0.3478548451374538573730639],
-		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
-		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
-		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
-		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
-		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
-		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
-		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
-		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
-		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
-		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
-		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
-		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
-	];
-
-	var abs = Math.abs,
-		sqrt = Math.sqrt,
-		pow = Math.pow,
-		log2 = Math.log2 || function(x) {
-			return Math.log(x) * Math.LOG2E;
-		},
-		EPSILON = 1e-12,
-		MACHINE_EPSILON = 1.12e-16;
-
-	function clamp(value, min, max) {
-		return value < min ? min : value > max ? max : value;
-	}
-
-	function getDiscriminant(a, b, c) {
-		function split(v) {
-			var x = v * 134217729,
-				y = v - x,
-				hi = y + x,
-				lo = v - hi;
-			return [hi, lo];
-		}
-
-		var D = b * b - a * c,
-			E = b * b + a * c;
-		if (abs(D) * 3 < E) {
-			var ad = split(a),
-				bd = split(b),
-				cd = split(c),
-				p = b * b,
-				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
-				q = a * c,
-				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
-						+ ad[1] * cd[1];
-			D = (p - q) + (dp - dq);
-		}
-		return D;
-	}
-
-	function getNormalizationFactor() {
-		var norm = Math.max.apply(Math, arguments);
-		return norm && (norm < 1e-8 || norm > 1e8)
-				? pow(2, -Math.round(log2(norm)))
-				: 0;
-	}
-
-	return {
-		EPSILON: EPSILON,
-		MACHINE_EPSILON: MACHINE_EPSILON,
-		CURVETIME_EPSILON: 1e-8,
-		GEOMETRIC_EPSILON: 1e-7,
-		TRIGONOMETRIC_EPSILON: 1e-8,
-		KAPPA: 4 * (sqrt(2) - 1) / 3,
-
-		isZero: function(val) {
-			return val >= -EPSILON && val <= EPSILON;
-		},
-
-		isMachineZero: function(val) {
-			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
-		},
-
-		clamp: clamp,
-
-		integrate: function(f, a, b, n) {
-			var x = abscissas[n - 2],
-				w = weights[n - 2],
-				A = (b - a) * 0.5,
-				B = A + a,
-				i = 0,
-				m = (n + 1) >> 1,
-				sum = n & 1 ? w[i++] * f(B) : 0;
-			while (i < m) {
-				var Ax = A * x[i];
-				sum += w[i++] * (f(B + Ax) + f(B - Ax));
-			}
-			return A * sum;
-		},
-
-		findRoot: function(f, df, x, a, b, n, tolerance) {
-			for (var i = 0; i < n; i++) {
-				var fx = f(x),
-					dx = fx / df(x),
-					nx = x - dx;
-				if (abs(dx) < tolerance) {
-					x = nx;
-					break;
-				}
-				if (fx > 0) {
-					b = x;
-					x = nx <= a ? (a + b) * 0.5 : nx;
-				} else {
-					a = x;
-					x = nx >= b ? (a + b) * 0.5 : nx;
-				}
-			}
-			return clamp(x, a, b);
-		},
-
-		solveQuadratic: function(a, b, c, roots, min, max) {
-			var x1, x2 = Infinity;
-			if (abs(a) < EPSILON) {
-				if (abs(b) < EPSILON)
-					return abs(c) < EPSILON ? -1 : 0;
-				x1 = -c / b;
-			} else {
-				b *= -0.5;
-				var D = getDiscriminant(a, b, c);
-				if (D && abs(D) < MACHINE_EPSILON) {
-					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
-					if (f) {
-						a *= f;
-						b *= f;
-						c *= f;
-						D = getDiscriminant(a, b, c);
-					}
-				}
-				if (D >= -MACHINE_EPSILON) {
-					var Q = D < 0 ? 0 : sqrt(D),
-						R = b + (b < 0 ? -Q : Q);
-					if (R === 0) {
-						x1 = c / a;
-						x2 = -x1;
-					} else {
-						x1 = R / a;
-						x2 = c / R;
-					}
-				}
-			}
-			var count = 0,
-				boundless = min == null,
-				minB = min - EPSILON,
-				maxB = max + EPSILON;
-			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
-				roots[count++] = boundless ? x1 : clamp(x1, min, max);
-			if (x2 !== x1
-					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
-				roots[count++] = boundless ? x2 : clamp(x2, min, max);
-			return count;
-		},
-
-		solveCubic: function(a, b, c, d, roots, min, max) {
-			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
-				x, b1, c2, qd, q;
-			if (f) {
-				a *= f;
-				b *= f;
-				c *= f;
-				d *= f;
-			}
-
-			function evaluate(x0) {
-				x = x0;
-				var tmp = a * x;
-				b1 = tmp + b;
-				c2 = b1 * x + c;
-				qd = (tmp + b1) * x + c2;
-				q = c2 * x + d;
-			}
-
-			if (abs(a) < EPSILON) {
-				a = b;
-				b1 = c;
-				c2 = d;
-				x = Infinity;
-			} else if (abs(d) < EPSILON) {
-				b1 = b;
-				c2 = c;
-				x = 0;
-			} else {
-				evaluate(-(b / a) / 3);
-				var t = q / a,
-					r = pow(abs(t), 1/3),
-					s = t < 0 ? -1 : 1,
-					td = -qd / a,
-					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
-					x0 = x - s * rd;
-				if (x0 !== x) {
-					do {
-						evaluate(x0);
-						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
-					} while (s * x0 > s * x);
-					if (abs(a) * x * x > abs(d / x)) {
-						c2 = -d / x;
-						b1 = (c2 - c) / x;
-					}
-				}
-			}
-			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
-				boundless = min == null;
-			if (isFinite(x) && (count === 0
-					|| count > 0 && x !== roots[0] && x !== roots[1])
-					&& (boundless || x > min - EPSILON && x < max + EPSILON))
-				roots[count++] = boundless ? x : clamp(x, min, max);
-			return count;
-		}
-	};
-};
-
-var UID = {
-	_id: 1,
-	_pools: {},
-
-	get: function(name) {
-		if (name) {
-			var pool = this._pools[name];
-			if (!pool)
-				pool = this._pools[name] = { _id: 1 };
-			return pool._id++;
-		} else {
-			return this._id++;
-		}
-	}
-};
-
-var Point = Base.extend({
-	_class: 'Point',
-	_readIndex: true,
-
-	initialize: function Point(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasY = typeof arg1 === 'number';
-			this._set(arg0, hasY ? arg1 : arg0);
-			if (reading)
-				read = hasY ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('angle' in obj) {
-				this._set(obj.length || 0, 0);
-				this.setAngle(obj.angle || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y) {
-		this.x = x;
-		this.y = y;
-		return this;
-	},
-
-	equals: function(point) {
-		return this === point || point
-				&& (this.x === point.x && this.y === point.y
-					|| Array.isArray(point)
-						&& this.x === point[0] && this.y === point[1])
-				|| false;
-	},
-
-	clone: function() {
-		return new Point(this.x, this.y);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x), f.number(this.y)];
-	},
-
-	getLength: function() {
-		return Math.sqrt(this.x * this.x + this.y * this.y);
-	},
-
-	setLength: function(length) {
-		if (this.isZero()) {
-			var angle = this._angle || 0;
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		} else {
-			var scale = length / this.getLength();
-			if (Numerical.isZero(scale))
-				this.getAngle();
-			this._set(
-				this.x * scale,
-				this.y * scale
-			);
-		}
-	},
-	getAngle: function() {
-		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
-	},
-
-	setAngle: function(angle) {
-		this.setAngleInRadians.call(this, angle * Math.PI / 180);
-	},
-
-	getAngleInDegrees: '#getAngle',
-	setAngleInDegrees: '#setAngle',
-
-	getAngleInRadians: function() {
-		if (!arguments.length) {
-			return this.isZero()
-					? this._angle || 0
-					: this._angle = Math.atan2(this.y, this.x);
-		} else {
-			var point = Point.read(arguments),
-				div = this.getLength() * point.getLength();
-			if (Numerical.isZero(div)) {
-				return NaN;
-			} else {
-				var a = this.dot(point) / div;
-				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
-			}
-		}
-	},
-
-	setAngleInRadians: function(angle) {
-		this._angle = angle;
-		if (!this.isZero()) {
-			var length = this.getLength();
-			this._set(
-				Math.cos(angle) * length,
-				Math.sin(angle) * length
-			);
-		}
-	},
-
-	getQuadrant: function() {
-		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
-	}
-}, {
-	beans: false,
-
-	getDirectedAngle: function() {
-		var point = Point.read(arguments);
-		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
-	},
-
-	getDistance: function() {
-		var args = arguments,
-			point = Point.read(args),
-			x = point.x - this.x,
-			y = point.y - this.y,
-			d = x * x + y * y,
-			squared = Base.read(args);
-		return squared ? d : Math.sqrt(d);
-	},
-
-	normalize: function(length) {
-		if (length === undefined)
-			length = 1;
-		var current = this.getLength(),
-			scale = current !== 0 ? length / current : 0,
-			point = new Point(this.x * scale, this.y * scale);
-		if (scale >= 0)
-			point._angle = this._angle;
-		return point;
-	},
-
-	rotate: function(angle, center) {
-		if (angle === 0)
-			return this.clone();
-		angle = angle * Math.PI / 180;
-		var point = center ? this.subtract(center) : this,
-			sin = Math.sin(angle),
-			cos = Math.cos(angle);
-		point = new Point(
-			point.x * cos - point.y * sin,
-			point.x * sin + point.y * cos
-		);
-		return center ? point.add(center) : point;
-	},
-
-	transform: function(matrix) {
-		return matrix ? matrix._transformPoint(this) : this;
-	},
-
-	add: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x + point.x, this.y + point.y);
-	},
-
-	subtract: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x - point.x, this.y - point.y);
-	},
-
-	multiply: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x * point.x, this.y * point.y);
-	},
-
-	divide: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x / point.x, this.y / point.y);
-	},
-
-	modulo: function() {
-		var point = Point.read(arguments);
-		return new Point(this.x % point.x, this.y % point.y);
-	},
-
-	negate: function() {
-		return new Point(-this.x, -this.y);
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this);
-	},
-
-	isClose: function() {
-		var args = arguments,
-			point = Point.read(args),
-			tolerance = Base.read(args);
-		return this.getDistance(point) <= tolerance;
-	},
-
-	isCollinear: function() {
-		var point = Point.read(arguments);
-		return Point.isCollinear(this.x, this.y, point.x, point.y);
-	},
-
-	isColinear: '#isCollinear',
-
-	isOrthogonal: function() {
-		var point = Point.read(arguments);
-		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.x) && isZero(this.y);
-	},
-
-	isNaN: function() {
-		return isNaN(this.x) || isNaN(this.y);
-	},
-
-	isInQuadrant: function(q) {
-		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
-			&& this.y * (q > 2 ? -1 : 1) >= 0;
-	},
-
-	dot: function() {
-		var point = Point.read(arguments);
-		return this.x * point.x + this.y * point.y;
-	},
-
-	cross: function() {
-		var point = Point.read(arguments);
-		return this.x * point.y - this.y * point.x;
-	},
-
-	project: function() {
-		var point = Point.read(arguments),
-			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
-		return new Point(
-			point.x * scale,
-			point.y * scale
-		);
-	},
-
-	statics: {
-		min: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.min(point1.x, point2.x),
-				Math.min(point1.y, point2.y)
-			);
-		},
-
-		max: function() {
-			var args = arguments,
-				point1 = Point.read(args),
-				point2 = Point.read(args);
-			return new Point(
-				Math.max(point1.x, point2.x),
-				Math.max(point1.y, point2.y)
-			);
-		},
-
-		random: function() {
-			return new Point(Math.random(), Math.random());
-		},
-
-		isCollinear: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * y2 - y1 * x2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		},
-
-		isOrthogonal: function(x1, y1, x2, y2) {
-			return Math.abs(x1 * x2 + y1 * y2)
-					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
-						* 1e-8;
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Point(op(this.x), op(this.y));
-	};
-}, {}));
-
-var LinkedPoint = Point.extend({
-	initialize: function Point(x, y, owner, setter) {
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner[this._setter](this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner[this._setter](this);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		return this._setter === 'setPosition' ? 4 : 0;
-	}
-});
-
-var Size = Base.extend({
-	_class: 'Size',
-	_readIndex: true,
-
-	initialize: function Size(arg0, arg1) {
-		var type = typeof arg0,
-			reading = this.__read,
-			read = 0;
-		if (type === 'number') {
-			var hasHeight = typeof arg1 === 'number';
-			this._set(arg0, hasHeight ? arg1 : arg0);
-			if (reading)
-				read = hasHeight ? 2 : 1;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0);
-			if (reading)
-				read = arg0 === null ? 1 : 0;
-		} else {
-			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
-			read = 1;
-			if (Array.isArray(obj)) {
-				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
-			} else if ('width' in obj) {
-				this._set(obj.width || 0, obj.height || 0);
-			} else if ('x' in obj) {
-				this._set(obj.x || 0, obj.y || 0);
-			} else {
-				this._set(0, 0);
-				read = 0;
-			}
-		}
-		if (reading)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(width, height) {
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	equals: function(size) {
-		return size === this || size && (this.width === size.width
-				&& this.height === size.height
-				|| Array.isArray(size) && this.width === size[0]
-					&& this.height === size[1]) || false;
-	},
-
-	clone: function() {
-		return new Size(this.width, this.height);
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height) + ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.width),
-				f.number(this.height)];
-	},
-
-	add: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width + size.width, this.height + size.height);
-	},
-
-	subtract: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width - size.width, this.height - size.height);
-	},
-
-	multiply: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width * size.width, this.height * size.height);
-	},
-
-	divide: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width / size.width, this.height / size.height);
-	},
-
-	modulo: function() {
-		var size = Size.read(arguments);
-		return new Size(this.width % size.width, this.height % size.height);
-	},
-
-	negate: function() {
-		return new Size(-this.width, -this.height);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this.width) && isZero(this.height);
-	},
-
-	isNaN: function() {
-		return isNaN(this.width) || isNaN(this.height);
-	},
-
-	statics: {
-		min: function(size1, size2) {
-			return new Size(
-				Math.min(size1.width, size2.width),
-				Math.min(size1.height, size2.height));
-		},
-
-		max: function(size1, size2) {
-			return new Size(
-				Math.max(size1.width, size2.width),
-				Math.max(size1.height, size2.height));
-		},
-
-		random: function() {
-			return new Size(Math.random(), Math.random());
-		}
-	}
-}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
-	var op = Math[key];
-	this[key] = function() {
-		return new Size(op(this.width), op(this.height));
-	};
-}, {}));
-
-var LinkedSize = Size.extend({
-	initialize: function Size(width, height, owner, setter) {
-		this._width = width;
-		this._height = height;
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(width, height, _dontNotify) {
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	},
-
-	getWidth: function() {
-		return this._width;
-	},
-
-	setWidth: function(width) {
-		this._width = width;
-		this._owner[this._setter](this);
-	},
-
-	getHeight: function() {
-		return this._height;
-	},
-
-	setHeight: function(height) {
-		this._height = height;
-		this._owner[this._setter](this);
-	}
-});
-
-var Rectangle = Base.extend({
-	_class: 'Rectangle',
-	_readIndex: true,
-	beans: true,
-
-	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
-		var args = arguments,
-			type = typeof arg0,
-			read;
-		if (type === 'number') {
-			this._set(arg0, arg1, arg2, arg3);
-			read = 4;
-		} else if (type === 'undefined' || arg0 === null) {
-			this._set(0, 0, 0, 0);
-			read = arg0 === null ? 1 : 0;
-		} else if (args.length === 1) {
-			if (Array.isArray(arg0)) {
-				this._set.apply(this, arg0);
-				read = 1;
-			} else if (arg0.x !== undefined || arg0.width !== undefined) {
-				this._set(arg0.x || 0, arg0.y || 0,
-						arg0.width || 0, arg0.height || 0);
-				read = 1;
-			} else if (arg0.from === undefined && arg0.to === undefined) {
-				this._set(0, 0, 0, 0);
-				if (Base.readSupported(args, this)) {
-					read = 1;
-				}
-			}
-		}
-		if (read === undefined) {
-			var frm = Point.readNamed(args, 'from'),
-				next = Base.peek(args),
-				x = frm.x,
-				y = frm.y,
-				width,
-				height;
-			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
-				var to = Point.readNamed(args, 'to');
-				width = to.x - x;
-				height = to.y - y;
-				if (width < 0) {
-					x = to.x;
-					width = -width;
-				}
-				if (height < 0) {
-					y = to.y;
-					height = -height;
-				}
-			} else {
-				var size = Size.read(args);
-				width = size.width;
-				height = size.height;
-			}
-			this._set(x, y, width, height);
-			read = args.__index;
-		}
-		var filtered = args.__filtered;
-		if (filtered)
-			this.__filtered = filtered;
-		if (this.__read)
-			this.__read = read;
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(x, y, width, height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-		return this;
-	},
-
-	clone: function() {
-		return new Rectangle(this.x, this.y, this.width, this.height);
-	},
-
-	equals: function(rect) {
-		var rt = Base.isPlainValue(rect)
-				? Rectangle.read(arguments)
-				: rect;
-		return rt === this
-				|| rt && this.x === rt.x && this.y === rt.y
-					&& this.width === rt.width && this.height === rt.height
-				|| false;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '{ x: ' + f.number(this.x)
-				+ ', y: ' + f.number(this.y)
-				+ ', width: ' + f.number(this.width)
-				+ ', height: ' + f.number(this.height)
-				+ ' }';
-	},
-
-	_serialize: function(options) {
-		var f = options.formatter;
-		return [f.number(this.x),
-				f.number(this.y),
-				f.number(this.width),
-				f.number(this.height)];
-	},
-
-	getPoint: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.x, this.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.x = point.x;
-		this.y = point.y;
-	},
-
-	getSize: function(_dontLink) {
-		var ctor = _dontLink ? Size : LinkedSize;
-		return new ctor(this.width, this.height, this, 'setSize');
-	},
-
-	_fw: 1,
-	_fh: 1,
-
-	setSize: function() {
-		var size = Size.read(arguments),
-			sx = this._sx,
-			sy = this._sy,
-			w = size.width,
-			h = size.height;
-		if (sx) {
-			this.x += (this.width - w) * sx;
-		}
-		if (sy) {
-			this.y += (this.height - h) * sy;
-		}
-		this.width = w;
-		this.height = h;
-		this._fw = this._fh = 1;
-	},
-
-	getLeft: function() {
-		return this.x;
-	},
-
-	setLeft: function(left) {
-		if (!this._fw) {
-			var amount = left - this.x;
-			this.width -= this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = left;
-		this._sx = this._fw = 0;
-	},
-
-	getTop: function() {
-		return this.y;
-	},
-
-	setTop: function(top) {
-		if (!this._fh) {
-			var amount = top - this.y;
-			this.height -= this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = top;
-		this._sy = this._fh = 0;
-	},
-
-	getRight: function() {
-		return this.x + this.width;
-	},
-
-	setRight: function(right) {
-		if (!this._fw) {
-			var amount = right - this.x;
-			this.width = this._sx === 0.5 ? amount * 2 : amount;
-		}
-		this.x = right - this.width;
-		this._sx = 1;
-		this._fw = 0;
-	},
-
-	getBottom: function() {
-		return this.y + this.height;
-	},
-
-	setBottom: function(bottom) {
-		if (!this._fh) {
-			var amount = bottom - this.y;
-			this.height = this._sy === 0.5 ? amount * 2 : amount;
-		}
-		this.y = bottom - this.height;
-		this._sy = 1;
-		this._fh = 0;
-	},
-
-	getCenterX: function() {
-		return this.x + this.width / 2;
-	},
-
-	setCenterX: function(x) {
-		if (this._fw || this._sx === 0.5) {
-			this.x = x - this.width / 2;
-		} else {
-			if (this._sx) {
-				this.x += (x - this.x) * 2 * this._sx;
-			}
-			this.width = (x - this.x) * 2;
-		}
-		this._sx = 0.5;
-		this._fw = 0;
-	},
-
-	getCenterY: function() {
-		return this.y + this.height / 2;
-	},
-
-	setCenterY: function(y) {
-		if (this._fh || this._sy === 0.5) {
-			this.y = y - this.height / 2;
-		} else {
-			if (this._sy) {
-				this.y += (y - this.y) * 2 * this._sy;
-			}
-			this.height = (y - this.y) * 2;
-		}
-		this._sy = 0.5;
-		this._fh = 0;
-	},
-
-	getCenter: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
-	},
-
-	setCenter: function() {
-		var point = Point.read(arguments);
-		this.setCenterX(point.x);
-		this.setCenterY(point.y);
-		return this;
-	},
-
-	getArea: function() {
-		return this.width * this.height;
-	},
-
-	isEmpty: function() {
-		return this.width === 0 || this.height === 0;
-	},
-
-	contains: function(arg) {
-		return arg && arg.width !== undefined
-				|| (Array.isArray(arg) ? arg : arguments).length === 4
-				? this._containsRectangle(Rectangle.read(arguments))
-				: this._containsPoint(Point.read(arguments));
-	},
-
-	_containsPoint: function(point) {
-		var x = point.x,
-			y = point.y;
-		return x >= this.x && y >= this.y
-				&& x <= this.x + this.width
-				&& y <= this.y + this.height;
-	},
-
-	_containsRectangle: function(rect) {
-		var x = rect.x,
-			y = rect.y;
-		return x >= this.x && y >= this.y
-				&& x + rect.width <= this.x + this.width
-				&& y + rect.height <= this.y + this.height;
-	},
-
-	intersects: function() {
-		var rect = Rectangle.read(arguments),
-			epsilon = Base.read(arguments) || 0;
-		return rect.x + rect.width > this.x - epsilon
-				&& rect.y + rect.height > this.y - epsilon
-				&& rect.x < this.x + this.width + epsilon
-				&& rect.y < this.y + this.height + epsilon;
-	},
-
-	intersect: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.max(this.x, rect.x),
-			y1 = Math.max(this.y, rect.y),
-			x2 = Math.min(this.x + this.width, rect.x + rect.width),
-			y2 = Math.min(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	unite: function() {
-		var rect = Rectangle.read(arguments),
-			x1 = Math.min(this.x, rect.x),
-			y1 = Math.min(this.y, rect.y),
-			x2 = Math.max(this.x + this.width, rect.x + rect.width),
-			y2 = Math.max(this.y + this.height, rect.y + rect.height);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	include: function() {
-		var point = Point.read(arguments);
-		var x1 = Math.min(this.x, point.x),
-			y1 = Math.min(this.y, point.y),
-			x2 = Math.max(this.x + this.width, point.x),
-			y2 = Math.max(this.y + this.height, point.y);
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	},
-
-	expand: function() {
-		var amount = Size.read(arguments),
-			hor = amount.width,
-			ver = amount.height;
-		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
-				this.width + hor, this.height + ver);
-	},
-
-	scale: function(hor, ver) {
-		return this.expand(this.width * hor - this.width,
-				this.height * (ver === undefined ? hor : ver) - this.height);
-	}
-}, Base.each([
-		['Top', 'Left'], ['Top', 'Right'],
-		['Bottom', 'Left'], ['Bottom', 'Right'],
-		['Left', 'Center'], ['Top', 'Center'],
-		['Right', 'Center'], ['Bottom', 'Center']
-	],
-	function(parts, index) {
-		var part = parts.join(''),
-			xFirst = /^[RL]/.test(part);
-		if (index >= 4)
-			parts[1] += xFirst ? 'Y' : 'X';
-		var x = parts[xFirst ? 0 : 1],
-			y = parts[xFirst ? 1 : 0],
-			getX = 'get' + x,
-			getY = 'get' + y,
-			setX = 'set' + x,
-			setY = 'set' + y,
-			get = 'get' + part,
-			set = 'set' + part;
-		this[get] = function(_dontLink) {
-			var ctor = _dontLink ? Point : LinkedPoint;
-			return new ctor(this[getX](), this[getY](), this, set);
-		};
-		this[set] = function() {
-			var point = Point.read(arguments);
-			this[setX](point.x);
-			this[setY](point.y);
-		};
-	}, {
-		beans: true
-	}
-));
-
-var LinkedRectangle = Rectangle.extend({
-	initialize: function Rectangle(x, y, width, height, owner, setter) {
-		this._set(x, y, width, height, true);
-		this._owner = owner;
-		this._setter = setter;
-	},
-
-	_set: function(x, y, width, height, _dontNotify) {
-		this._x = x;
-		this._y = y;
-		this._width = width;
-		this._height = height;
-		if (!_dontNotify)
-			this._owner[this._setter](this);
-		return this;
-	}
-},
-new function() {
-	var proto = Rectangle.prototype;
-
-	return Base.each(['x', 'y', 'width', 'height'], function(key) {
-		var part = Base.capitalize(key),
-			internal = '_' + key;
-		this['get' + part] = function() {
-			return this[internal];
-		};
-
-		this['set' + part] = function(value) {
-			this[internal] = value;
-			if (!this._dontNotify)
-				this._owner[this._setter](this);
-		};
-	}, Base.each(['Point', 'Size', 'Center',
-			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
-			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
-		function(key) {
-			var name = 'set' + key;
-			this[name] = function() {
-				this._dontNotify = true;
-				proto[name].apply(this, arguments);
-				this._dontNotify = false;
-				this._owner[this._setter](this);
-			};
-		}, {
-			isSelected: function() {
-				return !!(this._owner._selection & 2);
-			},
-
-			setSelected: function(selected) {
-				var owner = this._owner;
-				if (owner._changeSelection) {
-					owner._changeSelection(2, selected);
-				}
-			}
-		})
-	);
-});
-
-var Matrix = Base.extend({
-	_class: 'Matrix',
-
-	initialize: function Matrix(arg, _dontNotify) {
-		var args = arguments,
-			count = args.length,
-			ok = true;
-		if (count >= 6) {
-			this._set.apply(this, args);
-		} else if (count === 1 || count === 2) {
-			if (arg instanceof Matrix) {
-				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
-						_dontNotify);
-			} else if (Array.isArray(arg)) {
-				this._set.apply(this,
-						_dontNotify ? arg.concat([_dontNotify]) : arg);
-			} else {
-				ok = false;
-			}
-		} else if (!count) {
-			this.reset();
-		} else {
-			ok = false;
-		}
-		if (!ok) {
-			throw new Error('Unsupported matrix parameters');
-		}
-		return this;
-	},
-
-	set: '#initialize',
-
-	_set: function(a, b, c, d, tx, ty, _dontNotify) {
-		this._a = a;
-		this._b = b;
-		this._c = c;
-		this._d = d;
-		this._tx = tx;
-		this._ty = ty;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.getValues(), options, true, dictionary);
-	},
-
-	_changed: function() {
-		var owner = this._owner;
-		if (owner) {
-			if (owner._applyMatrix) {
-				owner.transform(null, true);
-			} else {
-				owner._changed(25);
-			}
-		}
-	},
-
-	clone: function() {
-		return new Matrix(this._a, this._b, this._c, this._d,
-				this._tx, this._ty);
-	},
-
-	equals: function(mx) {
-		return mx === this || mx && this._a === mx._a && this._b === mx._b
-				&& this._c === mx._c && this._d === mx._d
-				&& this._tx === mx._tx && this._ty === mx._ty;
-	},
-
-	toString: function() {
-		var f = Formatter.instance;
-		return '[[' + [f.number(this._a), f.number(this._c),
-					f.number(this._tx)].join(', ') + '], ['
-				+ [f.number(this._b), f.number(this._d),
-					f.number(this._ty)].join(', ') + ']]';
-	},
-
-	reset: function(_dontNotify) {
-		this._a = this._d = 1;
-		this._b = this._c = this._tx = this._ty = 0;
-		if (!_dontNotify)
-			this._changed();
-		return this;
-	},
-
-	apply: function(recursively, _setApplyMatrix) {
-		var owner = this._owner;
-		if (owner) {
-			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
-			return this.isIdentity();
-		}
-		return false;
-	},
-
-	translate: function() {
-		var point = Point.read(arguments),
-			x = point.x,
-			y = point.y;
-		this._tx += x * this._a + y * this._c;
-		this._ty += x * this._b + y * this._d;
-		this._changed();
-		return this;
-	},
-
-	scale: function() {
-		var args = arguments,
-			scale = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		this._a *= scale.x;
-		this._b *= scale.x;
-		this._c *= scale.y;
-		this._d *= scale.y;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	rotate: function(angle ) {
-		angle *= Math.PI / 180;
-		var center = Point.read(arguments, 1),
-			x = center.x,
-			y = center.y,
-			cos = Math.cos(angle),
-			sin = Math.sin(angle),
-			tx = x - x * cos + y * sin,
-			ty = y - x * sin - y * cos,
-			a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d;
-		this._a = cos * a + sin * c;
-		this._b = cos * b + sin * d;
-		this._c = -sin * a + cos * c;
-		this._d = -sin * b + cos * d;
-		this._tx += tx * a + ty * c;
-		this._ty += tx * b + ty * d;
-		this._changed();
-		return this;
-	},
-
-	shear: function() {
-		var args = arguments,
-			shear = Point.read(args),
-			center = Point.read(args, 0, { readNull: true });
-		if (center)
-			this.translate(center);
-		var a = this._a,
-			b = this._b;
-		this._a += shear.y * this._c;
-		this._b += shear.y * this._d;
-		this._c += shear.x * a;
-		this._d += shear.x * b;
-		if (center)
-			this.translate(center.negate());
-		this._changed();
-		return this;
-	},
-
-	skew: function() {
-		var args = arguments,
-			skew = Point.read(args),
-			center = Point.read(args, 0, { readNull: true }),
-			toRadians = Math.PI / 180,
-			shear = new Point(Math.tan(skew.x * toRadians),
-				Math.tan(skew.y * toRadians));
-		return this.shear(shear, center);
-	},
-
-	append: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + c2 * c1;
-			this._c = b2 * a1 + d2 * c1;
-			this._b = a2 * b1 + c2 * d1;
-			this._d = b2 * b1 + d2 * d1;
-			this._tx += tx2 * a1 + ty2 * c1;
-			this._ty += tx2 * b1 + ty2 * d1;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	prepend: function(mx, _dontNotify) {
-		if (mx) {
-			var a1 = this._a,
-				b1 = this._b,
-				c1 = this._c,
-				d1 = this._d,
-				tx1 = this._tx,
-				ty1 = this._ty,
-				a2 = mx._a,
-				b2 = mx._c,
-				c2 = mx._b,
-				d2 = mx._d,
-				tx2 = mx._tx,
-				ty2 = mx._ty;
-			this._a = a2 * a1 + b2 * b1;
-			this._c = a2 * c1 + b2 * d1;
-			this._b = c2 * a1 + d2 * b1;
-			this._d = c2 * c1 + d2 * d1;
-			this._tx = a2 * tx1 + b2 * ty1 + tx2;
-			this._ty = c2 * tx1 + d2 * ty1 + ty2;
-			if (!_dontNotify)
-				this._changed();
-		}
-		return this;
-	},
-
-	appended: function(mx) {
-		return this.clone().append(mx);
-	},
-
-	prepended: function(mx) {
-		return this.clone().prepend(mx);
-	},
-
-	invert: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			this._a = d / det;
-			this._b = -b / det;
-			this._c = -c / det;
-			this._d = a / det;
-			this._tx = (c * ty - d * tx) / det;
-			this._ty = (b * tx - a * ty) / det;
-			res = this;
-		}
-		return res;
-	},
-
-	inverted: function() {
-		return this.clone().invert();
-	},
-
-	concatenate: '#append',
-	preConcatenate: '#prepend',
-	chain: '#appended',
-
-	_shiftless: function() {
-		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
-	},
-
-	_orNullIfIdentity: function() {
-		return this.isIdentity() ? null : this;
-	},
-
-	isIdentity: function() {
-		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
-				&& this._tx === 0 && this._ty === 0;
-	},
-
-	isInvertible: function() {
-		var det = this._a * this._d - this._c * this._b;
-		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
-	},
-
-	isSingular: function() {
-		return !this.isInvertible();
-	},
-
-	transform: function( src, dst, count) {
-		return arguments.length < 3
-			? this._transformPoint(Point.read(arguments))
-			: this._transformCoordinates(src, dst, count);
-	},
-
-	_transformPoint: function(point, dest, _dontNotify) {
-		var x = point.x,
-			y = point.y;
-		if (!dest)
-			dest = new Point();
-		return dest._set(
-				x * this._a + y * this._c + this._tx,
-				x * this._b + y * this._d + this._ty,
-				_dontNotify);
-	},
-
-	_transformCoordinates: function(src, dst, count) {
-		for (var i = 0, max = 2 * count; i < max; i += 2) {
-			var x = src[i],
-				y = src[i + 1];
-			dst[i] = x * this._a + y * this._c + this._tx;
-			dst[i + 1] = x * this._b + y * this._d + this._ty;
-		}
-		return dst;
-	},
-
-	_transformCorners: function(rect) {
-		var x1 = rect.x,
-			y1 = rect.y,
-			x2 = x1 + rect.width,
-			y2 = y1 + rect.height,
-			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
-		return this._transformCoordinates(coords, coords, 4);
-	},
-
-	_transformBounds: function(bounds, dest, _dontNotify) {
-		var coords = this._transformCorners(bounds),
-			min = coords.slice(0, 2),
-			max = min.slice();
-		for (var i = 2; i < 8; i++) {
-			var val = coords[i],
-				j = i & 1;
-			if (val < min[j]) {
-				min[j] = val;
-			} else if (val > max[j]) {
-				max[j] = val;
-			}
-		}
-		if (!dest)
-			dest = new Rectangle();
-		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
-				_dontNotify);
-	},
-
-	inverseTransform: function() {
-		return this._inverseTransform(Point.read(arguments));
-	},
-
-	_inverseTransform: function(point, dest, _dontNotify) {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			tx = this._tx,
-			ty = this._ty,
-			det = a * d - b * c,
-			res = null;
-		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
-			var x = point.x - this._tx,
-				y = point.y - this._ty;
-			if (!dest)
-				dest = new Point();
-			res = dest._set(
-					(x * d - y * c) / det,
-					(y * a - x * b) / det,
-					_dontNotify);
-		}
-		return res;
-	},
-
-	decompose: function() {
-		var a = this._a,
-			b = this._b,
-			c = this._c,
-			d = this._d,
-			det = a * d - b * c,
-			sqrt = Math.sqrt,
-			atan2 = Math.atan2,
-			degrees = 180 / Math.PI,
-			rotate,
-			scale,
-			skew;
-		if (a !== 0 || b !== 0) {
-			var r = sqrt(a * a + b * b);
-			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
-			scale = [r, det / r];
-			skew = [atan2(a * c + b * d, r * r), 0];
-		} else if (c !== 0 || d !== 0) {
-			var s = sqrt(c * c + d * d);
-			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
-			scale = [det / s, s];
-			skew = [0, atan2(a * c + b * d, s * s)];
-		} else {
-			rotate = 0;
-			skew = scale = [0, 0];
-		}
-		return {
-			translation: this.getTranslation(),
-			rotation: rotate * degrees,
-			scaling: new Point(scale),
-			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
-		};
-	},
-
-	getValues: function() {
-		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
-	},
-
-	getTranslation: function() {
-		return new Point(this._tx, this._ty);
-	},
-
-	getScaling: function() {
-		return this.decompose().scaling;
-	},
-
-	getRotation: function() {
-		return this.decompose().rotation;
-	},
-
-	applyToContext: function(ctx) {
-		if (!this.isIdentity()) {
-			ctx.transform(this._a, this._b, this._c, this._d,
-					this._tx, this._ty);
-		}
-	}
-}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
-	var part = Base.capitalize(key),
-		prop = '_' + key;
-	this['get' + part] = function() {
-		return this[prop];
-	};
-	this['set' + part] = function(value) {
-		this[prop] = value;
-		this._changed();
-	};
-}, {}));
-
-var Line = Base.extend({
-	_class: 'Line',
-
-	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
-		var asVector = false;
-		if (arguments.length >= 4) {
-			this._px = arg0;
-			this._py = arg1;
-			this._vx = arg2;
-			this._vy = arg3;
-			asVector = arg4;
-		} else {
-			this._px = arg0.x;
-			this._py = arg0.y;
-			this._vx = arg1.x;
-			this._vy = arg1.y;
-			asVector = arg2;
-		}
-		if (!asVector) {
-			this._vx -= this._px;
-			this._vy -= this._py;
-		}
-	},
-
-	getPoint: function() {
-		return new Point(this._px, this._py);
-	},
-
-	getVector: function() {
-		return new Point(this._vx, this._vy);
-	},
-
-	getLength: function() {
-		return this.getVector().getLength();
-	},
-
-	intersect: function(line, isInfinite) {
-		return Line.intersect(
-				this._px, this._py, this._vx, this._vy,
-				line._px, line._py, line._vx, line._vy,
-				true, isInfinite);
-	},
-
-	getSide: function(point, isInfinite) {
-		return Line.getSide(
-				this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true, isInfinite);
-	},
-
-	getDistance: function(point) {
-		return Math.abs(this.getSignedDistance(point));
-	},
-
-	getSignedDistance: function(point) {
-		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
-				point.x, point.y, true);
-	},
-
-	isCollinear: function(line) {
-		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	isOrthogonal: function(line) {
-		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
-	},
-
-	statics: {
-		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
-				isInfinite) {
-			if (!asVector) {
-				v1x -= p1x;
-				v1y -= p1y;
-				v2x -= p2x;
-				v2y -= p2y;
-			}
-			var cross = v1x * v2y - v1y * v2x;
-			if (!Numerical.isMachineZero(cross)) {
-				var dx = p1x - p2x,
-					dy = p1y - p2y,
-					u1 = (v2x * dy - v2y * dx) / cross,
-					u2 = (v1x * dy - v1y * dx) / cross,
-					epsilon = 1e-12,
-					uMin = -epsilon,
-					uMax = 1 + epsilon;
-				if (isInfinite
-						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
-					if (!isInfinite) {
-						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
-					}
-					return new Point(
-							p1x + u1 * v1x,
-							p1y + u1 * v1y);
-				}
-			}
-		},
-
-		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			var v2x = x - px,
-				v2y = y - py,
-				ccw = v2x * vy - v2y * vx;
-			if (!isInfinite && Numerical.isMachineZero(ccw)) {
-				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
-				if (ccw >= 0 && ccw <= 1)
-					ccw = 0;
-			}
-			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
-		},
-
-		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
-			if (!asVector) {
-				vx -= px;
-				vy -= py;
-			}
-			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
-					: vy === 0 ? (vx < 0 ? y - py : py - y)
-					: ((x - px) * vy - (y - py) * vx) / (
-						vy > vx
-							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
-							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
-					);
-		},
-
-		getDistance: function(px, py, vx, vy, x, y, asVector) {
-			return Math.abs(
-					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
-		}
-	}
-});
-
-var Project = PaperScopeItem.extend({
-	_class: 'Project',
-	_list: 'projects',
-	_reference: 'project',
-	_compactSerialize: true,
-
-	initialize: function Project(element) {
-		PaperScopeItem.call(this, true);
-		this._children = [];
-		this._namedChildren = {};
-		this._activeLayer = null;
-		this._currentStyle = new Style(null, null, this);
-		this._view = View.create(this,
-				element || CanvasProvider.getCanvas(1, 1));
-		this._selectionItems = {};
-		this._selectionCount = 0;
-		this._updateVersion = 0;
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this._children, options, true, dictionary);
-	},
-
-	_changed: function(flags, item) {
-		if (flags & 1) {
-			var view = this._view;
-			if (view) {
-				view._needsUpdate = true;
-				if (!view._requested && view._autoUpdate)
-					view.requestUpdate();
-			}
-		}
-		var changes = this._changes;
-		if (changes && item) {
-			var changesById = this._changesById,
-				id = item._id,
-				entry = changesById[id];
-			if (entry) {
-				entry.flags |= flags;
-			} else {
-				changes.push(changesById[id] = { item: item, flags: flags });
-			}
-		}
-	},
-
-	clear: function() {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--)
-			children[i].remove();
-	},
-
-	isEmpty: function() {
-		return !this._children.length;
-	},
-
-	remove: function remove() {
-		if (!remove.base.call(this))
-			return false;
-		if (this._view)
-			this._view.remove();
-		return true;
-	},
-
-	getView: function() {
-		return this._view;
-	},
-
-	getCurrentStyle: function() {
-		return this._currentStyle;
-	},
-
-	setCurrentStyle: function(style) {
-		this._currentStyle.set(style);
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	getOptions: function() {
-		return this._scope.settings;
-	},
-
-	getLayers: function() {
-		return this._children;
-	},
-
-	getActiveLayer: function() {
-		return this._activeLayer || new Layer({ project: this, insert: true });
-	},
-
-	getSymbolDefinitions: function() {
-		var definitions = [],
-			ids = {};
-		this.getItems({
-			class: SymbolItem,
-			match: function(item) {
-				var definition = item._definition,
-					id = definition._id;
-				if (!ids[id]) {
-					ids[id] = true;
-					definitions.push(definition);
-				}
-				return false;
-			}
-		});
-		return definitions;
-	},
-
-	getSymbols: 'getSymbolDefinitions',
-
-	getSelectedItems: function() {
-		var selectionItems = this._selectionItems,
-			items = [];
-		for (var id in selectionItems) {
-			var item = selectionItems[id],
-				selection = item._selection;
-			if ((selection & 1) && item.isInserted()) {
-				items.push(item);
-			} else if (!selection) {
-				this._updateSelection(item);
-			}
-		}
-		return items;
-	},
-
-	_updateSelection: function(item) {
-		var id = item._id,
-			selectionItems = this._selectionItems;
-		if (item._selection) {
-			if (selectionItems[id] !== item) {
-				this._selectionCount++;
-				selectionItems[id] = item;
-			}
-		} else if (selectionItems[id] === item) {
-			this._selectionCount--;
-			delete selectionItems[id];
-		}
-	},
-
-	selectAll: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].setFullySelected(true);
-	},
-
-	deselectAll: function() {
-		var selectionItems = this._selectionItems;
-		for (var i in selectionItems)
-			selectionItems[i].setFullySelected(false);
-	},
-
-	addLayer: function(layer) {
-		return this.insertLayer(undefined, layer);
-	},
-
-	insertLayer: function(index, layer) {
-		if (layer instanceof Layer) {
-			layer._remove(false, true);
-			Base.splice(this._children, [layer], index, 0);
-			layer._setProject(this, true);
-			var name = layer._name;
-			if (name)
-				layer.setName(name);
-			if (this._changes)
-				layer._changed(5);
-			if (!this._activeLayer)
-				this._activeLayer = layer;
-		} else {
-			layer = null;
-		}
-		return layer;
-	},
-
-	_insertItem: function(index, item, _created) {
-		item = this.insertLayer(index, item)
-				|| (this._activeLayer || this._insertItem(undefined,
-						new Layer(Item.NO_INSERT), true))
-						.insertChild(index, item);
-		if (_created && item.activate)
-			item.activate();
-		return item;
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, null, null, true)[0] || null;
-	},
-
-	importJSON: function(json) {
-		this.activate();
-		var layer = this._activeLayer;
-		return Base.importJSON(json, layer && layer.isEmpty() && layer);
-	},
-
-	removeOn: function(type) {
-		var sets = this._removeSets;
-		if (sets) {
-			if (type === 'mouseup')
-				sets.mousedrag = null;
-			var set = sets[type];
-			if (set) {
-				for (var id in set) {
-					var item = set[id];
-					for (var key in sets) {
-						var other = sets[key];
-						if (other && other != set)
-							delete other[item._id];
-					}
-					item.remove();
-				}
-				sets[type] = null;
-			}
-		}
-	},
-
-	draw: function(ctx, matrix, pixelRatio) {
-		this._updateVersion++;
-		ctx.save();
-		matrix.applyToContext(ctx);
-		var children = this._children,
-			param = new Base({
-				offset: new Point(0, 0),
-				pixelRatio: pixelRatio,
-				viewMatrix: matrix.isIdentity() ? null : matrix,
-				matrices: [new Matrix()],
-				updateMatrix: true
-			});
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].draw(ctx, param);
-		}
-		ctx.restore();
-
-		if (this._selectionCount > 0) {
-			ctx.save();
-			ctx.strokeWidth = 1;
-			var items = this._selectionItems,
-				size = this._scope.settings.handleSize,
-				version = this._updateVersion;
-			for (var id in items) {
-				items[id]._drawSelection(ctx, matrix, size, items, version);
-			}
-			ctx.restore();
-		}
-	}
-});
-
-var Item = Base.extend(Emitter, {
-	statics: {
-		extend: function extend(src) {
-			if (src._serializeFields)
-				src._serializeFields = Base.set({},
-					this.prototype._serializeFields, src._serializeFields);
-			return extend.base.apply(this, arguments);
-		},
-
-		NO_INSERT: { insert: false }
-	},
-
-	_class: 'Item',
-	_name: null,
-	_applyMatrix: true,
-	_canApplyMatrix: true,
-	_canScaleStroke: false,
-	_pivot: null,
-	_visible: true,
-	_blendMode: 'normal',
-	_opacity: 1,
-	_locked: false,
-	_guide: false,
-	_clipMask: false,
-	_selection: 0,
-	_selectBounds: true,
-	_selectChildren: false,
-	_serializeFields: {
-		name: null,
-		applyMatrix: null,
-		matrix: new Matrix(),
-		pivot: null,
-		visible: true,
-		blendMode: 'normal',
-		opacity: 1,
-		locked: false,
-		guide: false,
-		clipMask: false,
-		selected: false,
-		data: {}
-	},
-	_prioritize: ['applyMatrix']
-},
-new function() {
-	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
-			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
-	return Base.each(handlers,
-		function(name) {
-			this._events[name] = {
-				install: function(type) {
-					this.getView()._countItemEvent(type, 1);
-				},
-
-				uninstall: function(type) {
-					this.getView()._countItemEvent(type, -1);
-				}
-			};
-		}, {
-			_events: {
-				onFrame: {
-					install: function() {
-						this.getView()._animateItem(this, true);
-					},
-
-					uninstall: function() {
-						this.getView()._animateItem(this, false);
-					}
-				},
-
-				onLoad: {},
-				onError: {}
-			},
-			statics: {
-				_itemHandlers: handlers
-			}
-		}
-	);
-}, {
-	initialize: function Item() {
-	},
-
-	_initialize: function(props, point) {
-		var hasProps = props && Base.isPlainObject(props),
-			internal = hasProps && props.internal === true,
-			matrix = this._matrix = new Matrix(),
-			project = hasProps && props.project || paper.project,
-			settings = paper.settings;
-		this._id = internal ? null : UID.get();
-		this._parent = this._index = null;
-		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
-		if (point)
-			matrix.translate(point);
-		matrix._owner = this;
-		this._style = new Style(project._currentStyle, this, project);
-		if (internal || hasProps && props.insert == false
-			|| !settings.insertItems && !(hasProps && props.insert === true)) {
-			this._setProject(project);
-		} else {
-			(hasProps && props.parent || project)
-					._insertItem(undefined, this, true);
-		}
-		if (hasProps && props !== Item.NO_INSERT) {
-			this.set(props, {
-				internal: true, insert: true, project: true, parent: true
-			});
-		}
-		return hasProps;
-	},
-
-	_serialize: function(options, dictionary) {
-		var props = {},
-			that = this;
-
-		function serialize(fields) {
-			for (var key in fields) {
-				var value = that[key];
-				if (!Base.equals(value, key === 'leading'
-						? fields.fontSize * 1.2 : fields[key])) {
-					props[key] = Base.serialize(value, options,
-							key !== 'data', dictionary);
-				}
-			}
-		}
-
-		serialize(this._serializeFields);
-		if (!(this instanceof Group))
-			serialize(this._style._defaults);
-		return [ this._class, props ];
-	},
-
-	_changed: function(flags) {
-		var symbol = this._symbol,
-			cacheParent = this._parent || symbol,
-			project = this._project;
-		if (flags & 8) {
-			this._bounds = this._position = this._decomposed = undefined;
-		}
-		if (flags & 16) {
-			this._globalMatrix = undefined;
-		}
-		if (cacheParent
-				&& (flags & 72)) {
-			Item._clearBoundsCache(cacheParent);
-		}
-		if (flags & 2) {
-			Item._clearBoundsCache(this);
-		}
-		if (project)
-			project._changed(flags, this);
-		if (symbol)
-			symbol._changed(flags);
-	},
-
-	getId: function() {
-		return this._id;
-	},
-
-	getName: function() {
-		return this._name;
-	},
-
-	setName: function(name) {
-
-		if (this._name)
-			this._removeNamed();
-		if (name === (+name) + '')
-			throw new Error(
-					'Names consisting only of numbers are not supported.');
-		var owner = this._getOwner();
-		if (name && owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren;
-			(namedChildren[name] = namedChildren[name] || []).push(this);
-			if (!(name in children))
-				children[name] = this;
-		}
-		this._name = name || undefined;
-		this._changed(256);
-	},
-
-	getStyle: function() {
-		return this._style;
-	},
-
-	setStyle: function(style) {
-		this.getStyle().set(style);
-	}
-}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
-	function(name) {
-		var part = Base.capitalize(name),
-			key = '_' + name,
-			flags = {
-				locked: 256,
-				visible: 265
-			};
-		this['get' + part] = function() {
-			return this[key];
-		};
-		this['set' + part] = function(value) {
-			if (value != this[key]) {
-				this[key] = value;
-				this._changed(flags[name] || 257);
-			}
-		};
-	},
-{}), {
-	beans: true,
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		if (selection !== this._selection) {
-			this._selection = selection;
-			var project = this._project;
-			if (project) {
-				project._updateSelection(this);
-				this._changed(257);
-			}
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				if (children[i].isSelected())
-					return true;
-		}
-		return !!(this._selection & 1);
-	},
-
-	setSelected: function(selected) {
-		if (this._selectChildren) {
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setSelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isFullySelected: function() {
-		var children = this._children,
-			selected = !!(this._selection & 1);
-		if (children && selected) {
-			for (var i = 0, l = children.length; i < l; i++)
-				if (!children[i].isFullySelected())
-					return false;
-			return true;
-		}
-		return selected;
-	},
-
-	setFullySelected: function(selected) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++)
-				children[i].setFullySelected(selected);
-		}
-		this._changeSelection(1, selected);
-	},
-
-	isClipMask: function() {
-		return this._clipMask;
-	},
-
-	setClipMask: function(clipMask) {
-		if (this._clipMask != (clipMask = !!clipMask)) {
-			this._clipMask = clipMask;
-			if (clipMask) {
-				this.setFillColor(null);
-				this.setStrokeColor(null);
-			}
-			this._changed(257);
-			if (this._parent)
-				this._parent._changed(2048);
-		}
-	},
-
-	getData: function() {
-		if (!this._data)
-			this._data = {};
-		return this._data;
-	},
-
-	setData: function(data) {
-		this._data = data;
-	},
-
-	getPosition: function(_dontLink) {
-		var ctor = _dontLink ? Point : LinkedPoint;
-		var position = this._position ||
-			(this._position = this._getPositionFromBounds());
-		return new ctor(position.x, position.y, this, 'setPosition');
-	},
-
-	setPosition: function() {
-		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
-	},
-
-	_getPositionFromBounds: function(bounds) {
-		return this._pivot
-				? this._matrix._transformPoint(this._pivot)
-				: (bounds || this.getBounds()).getCenter(true);
-	},
-
-	getPivot: function() {
-		var pivot = this._pivot;
-		return pivot
-				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
-				: null;
-	},
-
-	setPivot: function() {
-		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
-		this._position = undefined;
-	}
-}, Base.each({
-		getStrokeBounds: { stroke: true },
-		getHandleBounds: { handle: true },
-		getInternalBounds: { internal: true }
-	},
-	function(options, key) {
-		this[key] = function(matrix) {
-			return this.getBounds(matrix, options);
-		};
-	},
-{
-	beans: true,
-
-	getBounds: function(matrix, options) {
-		var hasMatrix = options || matrix instanceof Matrix,
-			opts = Base.set({}, hasMatrix ? options : matrix,
-					this._boundsOptions);
-		if (!opts.stroke || this.getStrokeScaling())
-			opts.cacheItem = this;
-		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
-		return !arguments.length
-				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
-					this, 'setBounds')
-				: rect;
-	},
-
-	setBounds: function() {
-		var rect = Rectangle.read(arguments),
-			bounds = this.getBounds(),
-			_matrix = this._matrix,
-			matrix = new Matrix(),
-			center = rect.getCenter();
-		matrix.translate(center);
-		if (rect.width != bounds.width || rect.height != bounds.height) {
-			if (!_matrix.isInvertible()) {
-				_matrix.set(_matrix._backup
-						|| new Matrix().translate(_matrix.getTranslation()));
-				bounds = this.getBounds();
-			}
-			matrix.scale(
-					bounds.width !== 0 ? rect.width / bounds.width : 0,
-					bounds.height !== 0 ? rect.height / bounds.height : 0);
-		}
-		center = bounds.getCenter();
-		matrix.translate(-center.x, -center.y);
-		this.transform(matrix);
-	},
-
-	_getBounds: function(matrix, options) {
-		var children = this._children;
-		if (!children || !children.length)
-			return new Rectangle();
-		Item._updateBoundsCache(this, options.cacheItem);
-		return Item._getBounds(children, matrix, options);
-	},
-
-	_getBoundsCacheKey: function(options, internal) {
-		return [
-			options.stroke ? 1 : 0,
-			options.handle ? 1 : 0,
-			internal ? 1 : 0
-		].join('');
-	},
-
-	_getCachedBounds: function(matrix, options, noInternal) {
-		matrix = matrix && matrix._orNullIfIdentity();
-		var internal = options.internal && !noInternal,
-			cacheItem = options.cacheItem,
-			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
-			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
-				&& this._getBoundsCacheKey(options, internal),
-			bounds = this._bounds;
-		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
-		if (cacheKey && bounds && cacheKey in bounds) {
-			var cached = bounds[cacheKey];
-			return {
-				rect: cached.rect.clone(),
-				nonscaling: cached.nonscaling
-			};
-		}
-		var res = this._getBounds(matrix || _matrix, options),
-			rect = res.rect || res,
-			style = this._style,
-			nonscaling = res.nonscaling || style.hasStroke()
-				&& !style.getStrokeScaling();
-		if (cacheKey) {
-			if (!bounds) {
-				this._bounds = bounds = {};
-			}
-			var cached = bounds[cacheKey] = {
-				rect: rect.clone(),
-				nonscaling: nonscaling,
-				internal: internal
-			};
-		}
-		return {
-			rect: rect,
-			nonscaling: nonscaling
-		};
-	},
-
-	_getStrokeMatrix: function(matrix, options) {
-		var parent = this.getStrokeScaling() ? null
-				: options && options.internal ? this
-					: this._parent || this._symbol && this._symbol._item,
-			mx = parent ? parent.getViewMatrix().invert() : matrix;
-		return mx && mx._shiftless();
-	},
-
-	statics: {
-		_updateBoundsCache: function(parent, item) {
-			if (parent && item) {
-				var id = item._id,
-					ref = parent._boundsCache = parent._boundsCache || {
-						ids: {},
-						list: []
-					};
-				if (!ref.ids[id]) {
-					ref.list.push(item);
-					ref.ids[id] = item;
-				}
-			}
-		},
-
-		_clearBoundsCache: function(item) {
-			var cache = item._boundsCache;
-			if (cache) {
-				item._bounds = item._position = item._boundsCache = undefined;
-				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
-					var other = list[i];
-					if (other !== item) {
-						other._bounds = other._position = undefined;
-						if (other._boundsCache)
-							Item._clearBoundsCache(other);
-					}
-				}
-			}
-		},
-
-		_getBounds: function(items, matrix, options) {
-			var x1 = Infinity,
-				x2 = -x1,
-				y1 = x1,
-				y2 = x2,
-				nonscaling = false;
-			options = options || {};
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i];
-				if (item._visible && !item.isEmpty(true)) {
-					var bounds = item._getCachedBounds(
-						matrix && matrix.appended(item._matrix), options, true),
-						rect = bounds.rect;
-					x1 = Math.min(rect.x, x1);
-					y1 = Math.min(rect.y, y1);
-					x2 = Math.max(rect.x + rect.width, x2);
-					y2 = Math.max(rect.y + rect.height, y2);
-					if (bounds.nonscaling)
-						nonscaling = true;
-				}
-			}
-			return {
-				rect: isFinite(x1)
-					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
-					: new Rectangle(),
-				nonscaling: nonscaling
-			};
-		}
-	}
-
-}), {
-	beans: true,
-
-	_decompose: function() {
-		return this._applyMatrix
-			? null
-			: this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	getRotation: function() {
-		var decomposed = this._decompose();
-		return decomposed ? decomposed.rotation : 0;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			var decomposed = this._decomposed;
-			this.rotate(rotation - current);
-			if (decomposed) {
-				decomposed.rotation = rotation;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getScaling: function() {
-		var decomposed = this._decompose(),
-			s = decomposed && decomposed.scaling;
-		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling && !current.equals(scaling)) {
-			var rotation = this.getRotation(),
-				decomposed = this._decomposed,
-				matrix = new Matrix(),
-				center = this.getPosition(true);
-			matrix.translate(center);
-			if (rotation)
-				matrix.rotate(rotation);
-			matrix.scale(scaling.x / current.x, scaling.y / current.y);
-			if (rotation)
-				matrix.rotate(-rotation);
-			matrix.translate(center.negate());
-			this.transform(matrix);
-			if (decomposed) {
-				decomposed.scaling = scaling;
-				this._decomposed = decomposed;
-			}
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	getGlobalMatrix: function(_dontClone) {
-		var matrix = this._globalMatrix;
-		if (matrix) {
-			var parent = this._parent;
-			var parents = [];
-			while (parent) {
-				if (!parent._globalMatrix) {
-					matrix = null;
-					for (var i = 0, l = parents.length; i < l; i++) {
-						parents[i]._globalMatrix = null;
-					}
-					break;
-				}
-				parents.push(parent);
-				parent = parent._parent;
-			}
-		}
-		if (!matrix) {
-			matrix = this._globalMatrix = this._matrix.clone();
-			var parent = this._parent;
-			if (parent)
-				matrix.prepend(parent.getGlobalMatrix(true));
-		}
-		return _dontClone ? matrix : matrix.clone();
-	},
-
-	getViewMatrix: function() {
-		return this.getGlobalMatrix().prepend(this.getView()._matrix);
-	},
-
-	getApplyMatrix: function() {
-		return this._applyMatrix;
-	},
-
-	setApplyMatrix: function(apply) {
-		if (this._applyMatrix = this._canApplyMatrix && !!apply)
-			this.transform(null, true);
-	},
-
-	getTransformContent: '#getApplyMatrix',
-	setTransformContent: '#setApplyMatrix',
-}, {
-	getProject: function() {
-		return this._project;
-	},
-
-	_setProject: function(project, installEvents) {
-		if (this._project !== project) {
-			if (this._project)
-				this._installEvents(false);
-			this._project = project;
-			var children = this._children;
-			for (var i = 0, l = children && children.length; i < l; i++)
-				children[i]._setProject(project);
-			installEvents = true;
-		}
-		if (installEvents)
-			this._installEvents(true);
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	_installEvents: function _installEvents(install) {
-		_installEvents.base.call(this, install);
-		var children = this._children;
-		for (var i = 0, l = children && children.length; i < l; i++)
-			children[i]._installEvents(install);
-	},
-
-	getLayer: function() {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent instanceof Layer)
-				return parent;
-		}
-		return null;
-	},
-
-	getParent: function() {
-		return this._parent;
-	},
-
-	setParent: function(item) {
-		return item.addChild(this);
-	},
-
-	_getOwner: '#getParent',
-
-	getChildren: function() {
-		return this._children;
-	},
-
-	setChildren: function(items) {
-		this.removeChildren();
-		this.addChildren(items);
-	},
-
-	getFirstChild: function() {
-		return this._children && this._children[0] || null;
-	},
-
-	getLastChild: function() {
-		return this._children && this._children[this._children.length - 1]
-				|| null;
-	},
-
-	getNextSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index + 1] || null;
-	},
-
-	getPreviousSibling: function() {
-		var owner = this._getOwner();
-		return owner && owner._children[this._index - 1] || null;
-	},
-
-	getIndex: function() {
-		return this._index;
-	},
-
-	equals: function(item) {
-		return item === this || item && this._class === item._class
-				&& this._style.equals(item._style)
-				&& this._matrix.equals(item._matrix)
-				&& this._locked === item._locked
-				&& this._visible === item._visible
-				&& this._blendMode === item._blendMode
-				&& this._opacity === item._opacity
-				&& this._clipMask === item._clipMask
-				&& this._guide === item._guide
-				&& this._equals(item)
-				|| false;
-	},
-
-	_equals: function(item) {
-		return Base.equals(this._children, item._children);
-	},
-
-	clone: function(options) {
-		var copy = new this.constructor(Item.NO_INSERT),
-			children = this._children,
-			insert = Base.pick(options ? options.insert : undefined,
-					options === undefined || options === true),
-			deep = Base.pick(options ? options.deep : undefined, true);
-		if (children)
-			copy.copyAttributes(this);
-		if (!children || deep)
-			copy.copyContent(this);
-		if (!children)
-			copy.copyAttributes(this);
-		if (insert)
-			copy.insertAbove(this);
-		var name = this._name,
-			parent = this._parent;
-		if (name && parent) {
-			var children = parent._children,
-				orig = name,
-				i = 1;
-			while (children[name])
-				name = orig + ' ' + (i++);
-			if (name !== orig)
-				copy.setName(name);
-		}
-		return copy;
-	},
-
-	copyContent: function(source) {
-		var children = source._children;
-		for (var i = 0, l = children && children.length; i < l; i++) {
-			this.addChild(children[i].clone(false), true);
-		}
-	},
-
-	copyAttributes: function(source, excludeMatrix) {
-		this.setStyle(source._style);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide'];
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i];
-			if (source.hasOwnProperty(key))
-				this[key] = source[key];
-		}
-		if (!excludeMatrix)
-			this._matrix.set(source._matrix, true);
-		this.setApplyMatrix(source._applyMatrix);
-		this.setPivot(source._pivot);
-		this.setSelection(source._selection);
-		var data = source._data,
-			name = source._name;
-		this._data = data ? Base.clone(data) : null;
-		if (name)
-			this.setName(name);
-	},
-
-	rasterize: function(resolution, insert) {
-		var bounds = this.getStrokeBounds(),
-			scale = (resolution || this.getView().getResolution()) / 72,
-			topLeft = bounds.getTopLeft().floor(),
-			bottomRight = bounds.getBottomRight().ceil(),
-			size = new Size(bottomRight.subtract(topLeft)),
-			raster = new Raster(Item.NO_INSERT);
-		if (!size.isZero()) {
-			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
-				ctx = canvas.getContext('2d'),
-				matrix = new Matrix().scale(scale).translate(topLeft.negate());
-			ctx.save();
-			matrix.applyToContext(ctx);
-			this.draw(ctx, new Base({ matrices: [matrix] }));
-			ctx.restore();
-			raster.setCanvas(canvas);
-		}
-		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
-				.scale(1 / scale));
-		if (insert === undefined || insert)
-			raster.insertAbove(this);
-		return raster;
-	},
-
-	contains: function() {
-		var matrix = this._matrix;
-		return (
-			matrix.isInvertible() &&
-			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
-		);
-	},
-
-	_contains: function(point) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				if (children[i].contains(point))
-					return true;
-			}
-			return false;
-		}
-		return point.isInside(this.getInternalBounds());
-	},
-
-	isInside: function() {
-		return Rectangle.read(arguments).contains(this.getBounds());
-	},
-
-	_asPathItem: function() {
-		return new Path.Rectangle({
-			rectangle: this.getInternalBounds(),
-			matrix: this._matrix,
-			insert: false,
-		});
-	},
-
-	intersects: function(item, _matrix) {
-		if (!(item instanceof Item))
-			return false;
-		return this._asPathItem().getIntersections(item._asPathItem(), null,
-				_matrix, true).length > 0;
-	}
-},
-new function() {
-	function hitTest() {
-		var args = arguments;
-		return this._hitTest(
-				Point.read(args),
-				HitResult.getOptions(args));
-	}
-
-	function hitTestAll() {
-		var args = arguments,
-			point = Point.read(args),
-			options = HitResult.getOptions(args),
-			all = [];
-		this._hitTest(point, new Base({ all: all }, options));
-		return all;
-	}
-
-	function hitTestChildren(point, options, viewMatrix, _exclude) {
-		var children = this._children;
-		if (children) {
-			for (var i = children.length - 1; i >= 0; i--) {
-				var child = children[i];
-				var res = child !== _exclude && child._hitTest(point, options,
-						viewMatrix);
-				if (res && !options.all)
-					return res;
-			}
-		}
-		return null;
-	}
-
-	Project.inject({
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTest: hitTestChildren
-	});
-
-	return {
-		hitTest: hitTest,
-		hitTestAll: hitTestAll,
-		_hitTestChildren: hitTestChildren,
-	};
-}, {
-
-	_hitTest: function(point, options, parentViewMatrix) {
-		if (this._locked || !this._visible || this._guide && !options.guides
-				|| this.isEmpty()) {
-			return null;
-		}
-
-		var matrix = this._matrix,
-			viewMatrix = parentViewMatrix
-					? parentViewMatrix.appended(matrix)
-					: this.getGlobalMatrix().prepend(this.getView()._matrix),
-			tolerance = Math.max(options.tolerance, 1e-12),
-			tolerancePadding = options._tolerancePadding = new Size(
-					Path._getStrokePadding(tolerance,
-						matrix._shiftless().invert()));
-		point = matrix._inverseTransform(point);
-		if (!point || !this._children &&
-			!this.getBounds({ internal: true, stroke: true, handle: true })
-				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
-			return null;
-		}
-
-		var checkSelf = !(options.guides && !this._guide
-				|| options.selected && !this.isSelected()
-				|| options.type && options.type !== Base.hyphenate(this._class)
-				|| options.class && !(this instanceof options.class)),
-			match = options.match,
-			that = this,
-			bounds,
-			res;
-
-		function filter(hit) {
-			if (hit && match && !match(hit))
-				hit = null;
-			if (hit && options.all)
-				options.all.push(hit);
-			return hit;
-		}
-
-		function checkPoint(type, part) {
-			var pt = part ? bounds['get' + part]() : that.getPosition();
-			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
-				return new HitResult(type, that, {
-					name: part ? Base.hyphenate(part) : type,
-					point: pt
-				});
-			}
-		}
-
-		var checkPosition = options.position,
-			checkCenter = options.center,
-			checkBounds = options.bounds;
-		if (checkSelf && this._parent
-				&& (checkPosition || checkCenter || checkBounds)) {
-			if (checkCenter || checkBounds) {
-				bounds = this.getInternalBounds();
-			}
-			res = checkPosition && checkPoint('position') ||
-					checkCenter && checkPoint('center', 'Center');
-			if (!res && checkBounds) {
-				var points = [
-					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
-					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
-				];
-				for (var i = 0; i < 8 && !res; i++) {
-					res = checkPoint('bounds', points[i]);
-				}
-			}
-			res = filter(res);
-		}
-
-		if (!res) {
-			res = this._hitTestChildren(point, options, viewMatrix)
-				|| checkSelf
-					&& filter(this._hitTestSelf(point, options, viewMatrix,
-						this.getStrokeScaling() ? null
-							: viewMatrix._shiftless().invert()))
-				|| null;
-		}
-		if (res && res.point) {
-			res.point = matrix.transform(res.point);
-		}
-		return res;
-	},
-
-	_hitTestSelf: function(point, options) {
-		if (options.fill && this.hasFill() && this._contains(point))
-			return new HitResult('fill', this);
-	},
-
-	matches: function(name, compare) {
-		function matchObject(obj1, obj2) {
-			for (var i in obj1) {
-				if (obj1.hasOwnProperty(i)) {
-					var val1 = obj1[i],
-						val2 = obj2[i];
-					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
-						if (!matchObject(val1, val2))
-							return false;
-					} else if (!Base.equals(val1, val2)) {
-						return false;
-					}
-				}
-			}
-			return true;
-		}
-		var type = typeof name;
-		if (type === 'object') {
-			for (var key in name) {
-				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
-					return false;
-			}
-			return true;
-		} else if (type === 'function') {
-			return name(this);
-		} else if (name === 'match') {
-			return compare(this);
-		} else {
-			var value = /^(empty|editable)$/.test(name)
-					? this['is' + Base.capitalize(name)]()
-					: name === 'type'
-						? Base.hyphenate(this._class)
-						: this[name];
-			if (name === 'class') {
-				if (typeof compare === 'function')
-					return this instanceof compare;
-				value = this._class;
-			}
-			if (typeof compare === 'function') {
-				return !!compare(value);
-			} else if (compare) {
-				if (compare.test) {
-					return compare.test(value);
-				} else if (Base.isPlainObject(compare)) {
-					return matchObject(compare, value);
-				}
-			}
-			return Base.equals(value, compare);
-		}
-	},
-
-	getItems: function(options) {
-		return Item._getItems(this, options, this._matrix);
-	},
-
-	getItem: function(options) {
-		return Item._getItems(this, options, this._matrix, null, true)[0]
-				|| null;
-	},
-
-	statics: {
-		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
-			if (!param) {
-				var obj = typeof options === 'object' && options,
-					overlapping = obj && obj.overlapping,
-					inside = obj && obj.inside,
-					bounds = overlapping || inside,
-					rect = bounds && Rectangle.read([bounds]);
-				param = {
-					items: [],
-					recursive: obj && obj.recursive !== false,
-					inside: !!inside,
-					overlapping: !!overlapping,
-					rect: rect,
-					path: overlapping && new Path.Rectangle({
-						rectangle: rect,
-						insert: false
-					})
-				};
-				if (obj) {
-					options = Base.filter({}, options, {
-						recursive: true, inside: true, overlapping: true
-					});
-				}
-			}
-			var children = item._children,
-				items = param.items,
-				rect = param.rect;
-			matrix = rect && (matrix || new Matrix());
-			for (var i = 0, l = children && children.length; i < l; i++) {
-				var child = children[i],
-					childMatrix = matrix && matrix.appended(child._matrix),
-					add = true;
-				if (rect) {
-					var bounds = child.getBounds(childMatrix);
-					if (!rect.intersects(bounds))
-						continue;
-					if (!(rect.contains(bounds)
-							|| param.overlapping && (bounds.contains(rect)
-								|| param.path.intersects(child, childMatrix))))
-						add = false;
-				}
-				if (add && child.matches(options)) {
-					items.push(child);
-					if (firstOnly)
-						break;
-				}
-				if (param.recursive !== false) {
-					_getItems(child, options, childMatrix, param, firstOnly);
-				}
-				if (firstOnly && items.length > 0)
-					break;
-			}
-			return items;
-		}
-	}
-}, {
-
-	importJSON: function(json) {
-		var res = Base.importJSON(json, this);
-		return res !== this ? this.addChild(res) : res;
-	},
-
-	addChild: function(item) {
-		return this.insertChild(undefined, item);
-	},
-
-	insertChild: function(index, item) {
-		var res = item ? this.insertChildren(index, [item]) : null;
-		return res && res[0];
-	},
-
-	addChildren: function(items) {
-		return this.insertChildren(this._children.length, items);
-	},
-
-	insertChildren: function(index, items) {
-		var children = this._children;
-		if (children && items && items.length > 0) {
-			items = Base.slice(items);
-			var inserted = {};
-			for (var i = items.length - 1; i >= 0; i--) {
-				var item = items[i],
-					id = item && item._id;
-				if (!item || inserted[id]) {
-					items.splice(i, 1);
-				} else {
-					item._remove(false, true);
-					inserted[id] = true;
-				}
-			}
-			Base.splice(children, items, index, 0);
-			var project = this._project,
-				notifySelf = project._changes;
-			for (var i = 0, l = items.length; i < l; i++) {
-				var item = items[i],
-					name = item._name;
-				item._parent = this;
-				item._setProject(project, true);
-				if (name)
-					item.setName(name);
-				if (notifySelf)
-					item._changed(5);
-			}
-			this._changed(11);
-		} else {
-			items = null;
-		}
-		return items;
-	},
-
-	_insertItem: '#insertChild',
-
-	_insertAt: function(item, offset) {
-		var owner = item && item._getOwner(),
-			res = item !== this && owner ? this : null;
-		if (res) {
-			res._remove(false, true);
-			owner._insertItem(item._index + offset, res);
-		}
-		return res;
-	},
-
-	insertAbove: function(item) {
-		return this._insertAt(item, 1);
-	},
-
-	insertBelow: function(item) {
-		return this._insertAt(item, 0);
-	},
-
-	sendToBack: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(0, this) : null;
-	},
-
-	bringToFront: function() {
-		var owner = this._getOwner();
-		return owner ? owner._insertItem(undefined, this) : null;
-	},
-
-	appendTop: '#addChild',
-
-	appendBottom: function(item) {
-		return this.insertChild(0, item);
-	},
-
-	moveAbove: '#insertAbove',
-
-	moveBelow: '#insertBelow',
-
-	addTo: function(owner) {
-		return owner._insertItem(undefined, this);
-	},
-
-	copyTo: function(owner) {
-		return this.clone(false).addTo(owner);
-	},
-
-	reduce: function(options) {
-		var children = this._children;
-		if (children && children.length === 1) {
-			var child = children[0].reduce(options);
-			if (this._parent) {
-				child.insertAbove(this);
-				this.remove();
-			} else {
-				child.remove();
-			}
-			return child;
-		}
-		return this;
-	},
-
-	_removeNamed: function() {
-		var owner = this._getOwner();
-		if (owner) {
-			var children = owner._children,
-				namedChildren = owner._namedChildren,
-				name = this._name,
-				namedArray = namedChildren[name],
-				index = namedArray ? namedArray.indexOf(this) : -1;
-			if (index !== -1) {
-				if (children[name] == this)
-					delete children[name];
-				namedArray.splice(index, 1);
-				if (namedArray.length) {
-					children[name] = namedArray[0];
-				} else {
-					delete namedChildren[name];
-				}
-			}
-		}
-	},
-
-	_remove: function(notifySelf, notifyParent) {
-		var owner = this._getOwner(),
-			project = this._project,
-			index = this._index;
-		if (this._style)
-			this._style._dispose();
-		if (owner) {
-			if (this._name)
-				this._removeNamed();
-			if (index != null) {
-				if (project._activeLayer === this)
-					project._activeLayer = this.getNextSibling()
-							|| this.getPreviousSibling();
-				Base.splice(owner._children, null, index, 1);
-			}
-			this._installEvents(false);
-			if (notifySelf && project._changes)
-				this._changed(5);
-			if (notifyParent)
-				owner._changed(11, this);
-			this._parent = null;
-			return true;
-		}
-		return false;
-	},
-
-	remove: function() {
-		return this._remove(true, true);
-	},
-
-	replaceWith: function(item) {
-		var ok = item && item.insertBelow(this);
-		if (ok)
-			this.remove();
-		return ok;
-	},
-
-	removeChildren: function(start, end) {
-		if (!this._children)
-			return null;
-		start = start || 0;
-		end = Base.pick(end, this._children.length);
-		var removed = Base.splice(this._children, null, start, end - start);
-		for (var i = removed.length - 1; i >= 0; i--) {
-			removed[i]._remove(true, false);
-		}
-		if (removed.length > 0)
-			this._changed(11);
-		return removed;
-	},
-
-	clear: '#removeChildren',
-
-	reverseChildren: function() {
-		if (this._children) {
-			this._children.reverse();
-			for (var i = 0, l = this._children.length; i < l; i++)
-				this._children[i]._index = i;
-			this._changed(11);
-		}
-	},
-
-	isEmpty: function(recursively) {
-		var children = this._children;
-		var numChildren = children ? children.length : 0;
-		if (recursively) {
-			for (var i = 0; i < numChildren; i++) {
-				if (!children[i].isEmpty(recursively)) {
-					return false;
-				}
-			}
-			return true;
-		}
-		return !numChildren;
-	},
-
-	isEditable: function() {
-		var item = this;
-		while (item) {
-			if (!item._visible || item._locked)
-				return false;
-			item = item._parent;
-		}
-		return true;
-	},
-
-	hasFill: function() {
-		return this.getStyle().hasFill();
-	},
-
-	hasStroke: function() {
-		return this.getStyle().hasStroke();
-	},
-
-	hasShadow: function() {
-		return this.getStyle().hasShadow();
-	},
-
-	_getOrder: function(item) {
-		function getList(item) {
-			var list = [];
-			do {
-				list.unshift(item);
-			} while (item = item._parent);
-			return list;
-		}
-		var list1 = getList(this),
-			list2 = getList(item);
-		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
-			if (list1[i] != list2[i]) {
-				return list1[i]._index < list2[i]._index ? 1 : -1;
-			}
-		}
-		return 0;
-	},
-
-	hasChildren: function() {
-		return this._children && this._children.length > 0;
-	},
-
-	isInserted: function() {
-		return this._parent ? this._parent.isInserted() : false;
-	},
-
-	isAbove: function(item) {
-		return this._getOrder(item) === -1;
-	},
-
-	isBelow: function(item) {
-		return this._getOrder(item) === 1;
-	},
-
-	isParent: function(item) {
-		return this._parent === item;
-	},
-
-	isChild: function(item) {
-		return item && item._parent === this;
-	},
-
-	isDescendant: function(item) {
-		var parent = this;
-		while (parent = parent._parent) {
-			if (parent === item)
-				return true;
-		}
-		return false;
-	},
-
-	isAncestor: function(item) {
-		return item ? item.isDescendant(this) : false;
-	},
-
-	isSibling: function(item) {
-		return this._parent === item._parent;
-	},
-
-	isGroupedWith: function(item) {
-		var parent = this._parent;
-		while (parent) {
-			if (parent._parent
-				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
-				&& item.isDescendant(parent))
-					return true;
-			parent = parent._parent;
-		}
-		return false;
-	},
-
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getPosition(true)));
-	};
-}, {
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
-		var _matrix = this._matrix,
-			transformMatrix = matrix && !matrix.isIdentity(),
-			applyMatrix = (
-				_setApplyMatrix && this._canApplyMatrix ||
-				this._applyMatrix && (
-					transformMatrix || !_matrix.isIdentity() ||
-					_applyRecursively && this._children
-				)
-			);
-		if (!transformMatrix && !applyMatrix)
-			return this;
-		if (transformMatrix) {
-			if (!matrix.isInvertible() && _matrix.isInvertible())
-				_matrix._backup = _matrix.getValues();
-			_matrix.prepend(matrix, true);
-			var style = this._style,
-				fillColor = style.getFillColor(true),
-				strokeColor = style.getStrokeColor(true);
-			if (fillColor)
-				fillColor.transform(matrix);
-			if (strokeColor)
-				strokeColor.transform(matrix);
-		}
-
-		if (applyMatrix && (applyMatrix = this._transformContent(
-				_matrix, _applyRecursively, _setApplyMatrix))) {
-			var pivot = this._pivot;
-			if (pivot)
-				_matrix._transformPoint(pivot, pivot, true);
-			_matrix.reset(true);
-			if (_setApplyMatrix && this._canApplyMatrix)
-				this._applyMatrix = true;
-		}
-		var bounds = this._bounds,
-			position = this._position;
-		if (transformMatrix || applyMatrix) {
-			this._changed(25);
-		}
-		var decomp = transformMatrix && bounds && matrix.decompose();
-		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
-			for (var key in bounds) {
-				var cache = bounds[key];
-				if (cache.nonscaling) {
-					delete bounds[key];
-				} else if (applyMatrix || !cache.internal) {
-					var rect = cache.rect;
-					matrix._transformBounds(rect, rect);
-				}
-			}
-			this._bounds = bounds;
-			var cached = bounds[this._getBoundsCacheKey(
-				this._boundsOptions || {})];
-			if (cached) {
-				this._position = this._getPositionFromBounds(cached.rect);
-			}
-		} else if (transformMatrix && position && this._pivot) {
-			this._position = matrix._transformPoint(position, position);
-		}
-		return this;
-	},
-
-	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
-		var children = this._children;
-		if (children) {
-			for (var i = 0, l = children.length; i < l; i++) {
-				children[i].transform(matrix, applyRecursively, setApplyMatrix);
-			}
-			return true;
-		}
-	},
-
-	globalToLocal: function() {
-		return this.getGlobalMatrix(true)._inverseTransform(
-				Point.read(arguments));
-	},
-
-	localToGlobal: function() {
-		return this.getGlobalMatrix(true)._transformPoint(
-				Point.read(arguments));
-	},
-
-	parentToLocal: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	localToParent: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	fitBounds: function(rectangle, fill) {
-		rectangle = Rectangle.read(arguments);
-		var bounds = this.getBounds(),
-			itemRatio = bounds.height / bounds.width,
-			rectRatio = rectangle.height / rectangle.width,
-			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
-					? rectangle.width / bounds.width
-					: rectangle.height / bounds.height,
-			newBounds = new Rectangle(new Point(),
-					new Size(bounds.width * scale, bounds.height * scale));
-		newBounds.setCenter(rectangle.getCenter());
-		this.setBounds(newBounds);
-	}
-}), {
-
-	_setStyles: function(ctx, param, viewMatrix) {
-		var style = this._style,
-			matrix = this._matrix;
-		if (style.hasFill()) {
-			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
-		}
-		if (style.hasStroke()) {
-			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
-			ctx.lineWidth = style.getStrokeWidth();
-			var strokeJoin = style.getStrokeJoin(),
-				strokeCap = style.getStrokeCap(),
-				miterLimit = style.getMiterLimit();
-			if (strokeJoin)
-				ctx.lineJoin = strokeJoin;
-			if (strokeCap)
-				ctx.lineCap = strokeCap;
-			if (miterLimit)
-				ctx.miterLimit = miterLimit;
-			if (paper.support.nativeDash) {
-				var dashArray = style.getDashArray(),
-					dashOffset = style.getDashOffset();
-				if (dashArray && dashArray.length) {
-					if ('setLineDash' in ctx) {
-						ctx.setLineDash(dashArray);
-						ctx.lineDashOffset = dashOffset;
-					} else {
-						ctx.mozDash = dashArray;
-						ctx.mozDashOffset = dashOffset;
-					}
-				}
-			}
-		}
-		if (style.hasShadow()) {
-			var pixelRatio = param.pixelRatio || 1,
-				mx = viewMatrix._shiftless().prepend(
-					new Matrix().scale(pixelRatio, pixelRatio)),
-				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
-				offset = mx.transform(this.getShadowOffset());
-			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
-			ctx.shadowBlur = blur.getLength();
-			ctx.shadowOffsetX = offset.x;
-			ctx.shadowOffsetY = offset.y;
-		}
-	},
-
-	draw: function(ctx, param, parentStrokeMatrix) {
-		var updateVersion = this._updateVersion = this._project._updateVersion;
-		if (!this._visible || this._opacity === 0)
-			return;
-		var matrices = param.matrices,
-			viewMatrix = param.viewMatrix,
-			matrix = this._matrix,
-			globalMatrix = matrices[matrices.length - 1].appended(matrix);
-		if (!globalMatrix.isInvertible())
-			return;
-
-		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
-				: globalMatrix;
-
-		matrices.push(globalMatrix);
-		if (param.updateMatrix) {
-			this._globalMatrix = globalMatrix;
-		}
-
-		var blendMode = this._blendMode,
-			opacity = Numerical.clamp(this._opacity, 0, 1),
-			normalBlend = blendMode === 'normal',
-			nativeBlend = BlendMode.nativeModes[blendMode],
-			direct = normalBlend && opacity === 1
-					|| param.dontStart
-					|| param.clip
-					|| (nativeBlend || normalBlend && opacity < 1)
-						&& this._canComposite(),
-			pixelRatio = param.pixelRatio || 1,
-			mainCtx, itemOffset, prevOffset;
-		if (!direct) {
-			var bounds = this.getStrokeBounds(viewMatrix);
-			if (!bounds.width || !bounds.height) {
-				matrices.pop();
-				return;
-			}
-			prevOffset = param.offset;
-			itemOffset = param.offset = bounds.getTopLeft().floor();
-			mainCtx = ctx;
-			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
-					.multiply(pixelRatio));
-			if (pixelRatio !== 1)
-				ctx.scale(pixelRatio, pixelRatio);
-		}
-		ctx.save();
-		var strokeMatrix = parentStrokeMatrix
-				? parentStrokeMatrix.appended(matrix)
-				: this._canScaleStroke && !this.getStrokeScaling(true)
-					&& viewMatrix,
-			clip = !direct && param.clipItem,
-			transform = !strokeMatrix || clip;
-		if (direct) {
-			ctx.globalAlpha = opacity;
-			if (nativeBlend)
-				ctx.globalCompositeOperation = blendMode;
-		} else if (transform) {
-			ctx.translate(-itemOffset.x, -itemOffset.y);
-		}
-		if (transform) {
-			(direct ? matrix : viewMatrix).applyToContext(ctx);
-		}
-		if (clip) {
-			param.clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		if (strokeMatrix) {
-			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-			var offset = param.offset;
-			if (offset)
-				ctx.translate(-offset.x, -offset.y);
-		}
-		this._draw(ctx, param, viewMatrix, strokeMatrix);
-		ctx.restore();
-		matrices.pop();
-		if (param.clip && !param.dontFinish) {
-			ctx.clip(this.getFillRule());
-		}
-		if (!direct) {
-			BlendMode.process(blendMode, ctx, mainCtx, opacity,
-					itemOffset.subtract(prevOffset).multiply(pixelRatio));
-			CanvasProvider.release(ctx);
-			param.offset = prevOffset;
-		}
-	},
-
-	_isUpdated: function(updateVersion) {
-		var parent = this._parent;
-		if (parent instanceof CompoundPath)
-			return parent._isUpdated(updateVersion);
-		var updated = this._updateVersion === updateVersion;
-		if (!updated && parent && parent._visible
-				&& parent._isUpdated(updateVersion)) {
-			this._updateVersion = updateVersion;
-			updated = true;
-		}
-		return updated;
-	},
-
-	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
-		var selection = this._selection,
-			itemSelected = selection & 1,
-			boundsSelected = selection & 2
-					|| itemSelected && this._selectBounds,
-			positionSelected = selection & 4;
-		if (!this._drawSelected)
-			itemSelected = false;
-		if ((itemSelected || boundsSelected || positionSelected)
-				&& this._isUpdated(updateVersion)) {
-			var layer,
-				color = this.getSelectedColor(true) || (layer = this.getLayer())
-					&& layer.getSelectedColor(true),
-				mx = matrix.appended(this.getGlobalMatrix(true)),
-				half = size / 2;
-			ctx.strokeStyle = ctx.fillStyle = color
-					? color.toCanvasStyle(ctx) : '#009dec';
-			if (itemSelected)
-				this._drawSelected(ctx, mx, selectionItems);
-			if (positionSelected) {
-				var pos = this.getPosition(true),
-					parent = this._parent,
-					point = parent ? parent.localToGlobal(pos) : pos,
-					x = point.x,
-					y = point.y;
-				ctx.beginPath();
-				ctx.arc(x, y, half, 0, Math.PI * 2, true);
-				ctx.stroke();
-				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
-					start = half,
-					end = size + 1;
-				for (var i = 0; i < 4; i++) {
-					var delta = deltas[i],
-						dx = delta[0],
-						dy = delta[1];
-					ctx.moveTo(x + dx * start, y + dy * start);
-					ctx.lineTo(x + dx * end, y + dy * end);
-					ctx.stroke();
-				}
-			}
-			if (boundsSelected) {
-				var coords = mx._transformCorners(this.getInternalBounds());
-				ctx.beginPath();
-				for (var i = 0; i < 8; i++) {
-					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
-				}
-				ctx.closePath();
-				ctx.stroke();
-				for (var i = 0; i < 8; i++) {
-					ctx.fillRect(coords[i] - half, coords[++i] - half,
-							size, size);
-				}
-			}
-		}
-	},
-
-	_canComposite: function() {
-		return false;
-	}
-}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
-	this['removeOn' + Base.capitalize(key)] = function() {
-		var hash = {};
-		hash[key] = true;
-		return this.removeOn(hash);
-	};
-}, {
-
-	removeOn: function(obj) {
-		for (var name in obj) {
-			if (obj[name]) {
-				var key = 'mouse' + name,
-					project = this._project,
-					sets = project._removeSets = project._removeSets || {};
-				sets[key] = sets[key] || {};
-				sets[key][this._id] = this;
-			}
-		}
-		return this;
-	}
-}), {
-	tween: function(from, to, options) {
-		if (!options) {
-			options = to;
-			to = from;
-			from = null;
-			if (!options) {
-				options = to;
-				to = null;
-			}
-		}
-		var easing = options && options.easing,
-			start = options && options.start,
-			duration = options != null && (
-				typeof options === 'number' ? options : options.duration
-			),
-			tween = new Tween(this, from, to, duration, easing, start);
-		function onFrame(event) {
-			tween._handleFrame(event.time * 1000);
-			if (!tween.running) {
-				this.off('frame', onFrame);
-			}
-		}
-		if (duration) {
-			this.on('frame', onFrame);
-		}
-		return tween;
-	},
-
-	tweenTo: function(to, options) {
-		return this.tween(null, to, options);
-	},
-
-	tweenFrom: function(from, options) {
-		return this.tween(from, null, options);
-	}
-});
-
-var Group = Item.extend({
-	_class: 'Group',
-	_selectBounds: false,
-	_selectChildren: true,
-	_serializeFields: {
-		children: []
-	},
-
-	initialize: function Group(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg))
-			this.addChildren(Array.isArray(arg) ? arg : arguments);
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 2050) {
-			this._clipItem = undefined;
-		}
-	},
-
-	_getClipItem: function() {
-		var clipItem = this._clipItem;
-		if (clipItem === undefined) {
-			clipItem = null;
-			var children = this._children;
-			for (var i = 0, l = children.length; i < l; i++) {
-				if (children[i]._clipMask) {
-					clipItem = children[i];
-					break;
-				}
-			}
-			this._clipItem = clipItem;
-		}
-		return clipItem;
-	},
-
-	isClipped: function() {
-		return !!this._getClipItem();
-	},
-
-	setClipped: function(clipped) {
-		var child = this.getFirstChild();
-		if (child)
-			child.setClipMask(clipped);
-	},
-
-	_getBounds: function _getBounds(matrix, options) {
-		var clipItem = this._getClipItem();
-		return clipItem
-			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
-				Base.set({}, options, { stroke: false }))
-			: _getBounds.base.call(this, matrix, options);
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		var clipItem = this._getClipItem();
-		return (!clipItem || clipItem.contains(point))
-				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
-					clipItem);
-	},
-
-	_draw: function(ctx, param) {
-		var clip = param.clip,
-			clipItem = !clip && this._getClipItem();
-		param = param.extend({ clipItem: clipItem, clip: false });
-		if (clip) {
-			ctx.beginPath();
-			param.dontStart = param.dontFinish = true;
-		} else if (clipItem) {
-			clipItem.draw(ctx, param.extend({ clip: true }));
-		}
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var item = children[i];
-			if (item !== clipItem)
-				item.draw(ctx, param);
-		}
-	}
-});
-
-var Layer = Group.extend({
-	_class: 'Layer',
-
-	initialize: function Layer() {
-		Group.apply(this, arguments);
-	},
-
-	_getOwner: function() {
-		return this._parent || this._index != null && this._project;
-	},
-
-	isInserted: function isInserted() {
-		return this._parent ? isInserted.base.call(this) : this._index != null;
-	},
-
-	activate: function() {
-		this._project._activeLayer = this;
-	},
-
-	_hitTestSelf: function() {
-	}
-});
-
-var Shape = Item.extend({
-	_class: 'Shape',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_canScaleStroke: true,
-	_serializeFields: {
-		type: null,
-		size: null,
-		radius: null
-	},
-
-	initialize: function Shape(props, point) {
-		this._initialize(props, point);
-	},
-
-	_equals: function(item) {
-		return this._type === item._type
-			&& this._size.equals(item._size)
-			&& Base.equals(this._radius, item._radius);
-	},
-
-	copyContent: function(source) {
-		this.setType(source._type);
-		this.setSize(source._size);
-		this.setRadius(source._radius);
-	},
-
-	getType: function() {
-		return this._type;
-	},
-
-	setType: function(type) {
-		this._type = type;
-	},
-
-	getShape: '#getType',
-	setShape: '#setType',
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size.width, size.height, this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!this._size) {
-			this._size = size.clone();
-		} else if (!this._size.equals(size)) {
-			var type = this._type,
-				width = size.width,
-				height = size.height;
-			if (type === 'rectangle') {
-				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
-			} else if (type === 'circle') {
-				width = height = (width + height) / 2;
-				this._radius = width / 2;
-			} else if (type === 'ellipse') {
-				this._radius._set(width / 2, height / 2);
-			}
-			this._size._set(width, height);
-			this._changed(9);
-		}
-	},
-
-	getRadius: function() {
-		var rad = this._radius;
-		return this._type === 'circle'
-				? rad
-				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
-	},
-
-	setRadius: function(radius) {
-		var type = this._type;
-		if (type === 'circle') {
-			if (radius === this._radius)
-				return;
-			var size = radius * 2;
-			this._radius = radius;
-			this._size._set(size, size);
-		} else {
-			radius = Size.read(arguments);
-			if (!this._radius) {
-				this._radius = radius.clone();
-			} else {
-				if (this._radius.equals(radius))
-					return;
-				this._radius.set(radius);
-				if (type === 'rectangle') {
-					var size = Size.max(this._size, radius.multiply(2));
-					this._size.set(size);
-				} else if (type === 'ellipse') {
-					this._size._set(radius.width * 2, radius.height * 2);
-				}
-			}
-		}
-		this._changed(9);
-	},
-
-	isEmpty: function() {
-		return false;
-	},
-
-	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
-			center: new Point(),
-			size: this._size,
-			radius: this._radius,
-			insert: false
-		});
-		path.copyAttributes(this);
-		if (paper.settings.applyMatrix)
-			path.setApplyMatrix(true);
-		if (insert === undefined || insert)
-			path.insertAbove(this);
-		return path;
-	},
-
-	toShape: '#clone',
-
-	_asPathItem: function() {
-		return this.toPath(false);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			dontPaint = param.dontFinish || param.clip,
-			untransformed = !strokeMatrix;
-		if (hasFill || hasStroke || dontPaint) {
-			var type = this._type,
-				radius = this._radius,
-				isCircle = type === 'circle';
-			if (!param.dontStart)
-				ctx.beginPath();
-			if (untransformed && isCircle) {
-				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
-			} else {
-				var rx = isCircle ? radius : radius.width,
-					ry = isCircle ? radius : radius.height,
-					size = this._size,
-					width = size.width,
-					height = size.height;
-				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
-					ctx.rect(-width / 2, -height / 2, width, height);
-				} else {
-					var x = width / 2,
-						y = height / 2,
-						kappa = 1 - 0.5522847498307936,
-						cx = rx * kappa,
-						cy = ry * kappa,
-						c = [
-							-x, -y + ry,
-							-x, -y + cy,
-							-x + cx, -y,
-							-x + rx, -y,
-							x - rx, -y,
-							x - cx, -y,
-							x, -y + cy,
-							x, -y + ry,
-							x, y - ry,
-							x, y - cy,
-							x - cx, y,
-							x - rx, y,
-							-x + rx, y,
-							-x + cx, y,
-							-x, y - cy,
-							-x, y - ry
-						];
-					if (strokeMatrix)
-						strokeMatrix.transform(c, c, 32);
-					ctx.moveTo(c[0], c[1]);
-					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
-					if (x !== rx)
-						ctx.lineTo(c[8], c[9]);
-					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
-					if (y !== ry)
-						ctx.lineTo(c[16], c[17]);
-					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
-					if (x !== rx)
-						ctx.lineTo(c[24], c[25]);
-					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
-				}
-			}
-			ctx.closePath();
-		}
-		if (!dontPaint && (hasFill || hasStroke)) {
-			this._setStyles(ctx, param, viewMatrix);
-			if (hasFill) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.stroke();
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0),
-			style = this._style,
-			strokeWidth = options.stroke && style.hasStroke()
-					&& style.getStrokeWidth();
-		if (matrix)
-			rect = matrix._transformBounds(rect);
-		return strokeWidth
-				? rect.expand(Path._getStrokePadding(strokeWidth,
-					this._getStrokeMatrix(matrix, options)))
-				: rect;
-	}
-},
-new function() {
-	function getCornerCenter(that, point, expand) {
-		var radius = that._radius;
-		if (!radius.isZero()) {
-			var halfSize = that._size.divide(2);
-			for (var q = 1; q <= 4; q++) {
-				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
-					corner = dir.multiply(halfSize),
-					center = corner.subtract(dir.multiply(radius)),
-					rect = new Rectangle(
-							expand ? corner.add(dir.multiply(expand)) : corner,
-							center);
-				if (rect.contains(point))
-					return { point: center, quadrant: q };
-			}
-		}
-	}
-
-	function isOnEllipseStroke(point, radius, padding, quadrant) {
-		var vector = point.divide(radius);
-		return (!quadrant || vector.isInQuadrant(quadrant)) &&
-				vector.subtract(vector.normalize()).multiply(radius)
-					.divide(padding).length <= 1;
-	}
-
-	return {
-		_contains: function _contains(point) {
-			if (this._type === 'rectangle') {
-				var center = getCornerCenter(this, point);
-				return center
-						? point.subtract(center.point).divide(this._radius)
-							.getLength() <= 1
-						: _contains.base.call(this, point);
-			} else {
-				return point.divide(this.size).getLength() <= 0.5;
-			}
-		},
-
-		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
-				strokeMatrix) {
-			var hit = false,
-				style = this._style,
-				hitStroke = options.stroke && style.hasStroke(),
-				hitFill = options.fill && style.hasFill();
-			if (hitStroke || hitFill) {
-				var type = this._type,
-					radius = this._radius,
-					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
-					strokePadding = options._tolerancePadding.add(
-						Path._getStrokePadding(strokeRadius,
-							!style.getStrokeScaling() && strokeMatrix));
-				if (type === 'rectangle') {
-					var padding = strokePadding.multiply(2),
-						center = getCornerCenter(this, point, padding);
-					if (center) {
-						hit = isOnEllipseStroke(point.subtract(center.point),
-								radius, strokePadding, center.quadrant);
-					} else {
-						var rect = new Rectangle(this._size).setCenter(0, 0),
-							outer = rect.expand(padding),
-							inner = rect.expand(padding.negate());
-						hit = outer._containsPoint(point)
-								&& !inner._containsPoint(point);
-					}
-				} else {
-					hit = isOnEllipseStroke(point, radius, strokePadding);
-				}
-			}
-			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
-					: _hitTestSelf.base.apply(this, arguments);
-		}
-	};
-}, {
-
-statics: new function() {
-	function createShape(type, point, size, radius, args) {
-		var item = Base.create(Shape.prototype);
-		item._type = type;
-		item._size = size;
-		item._radius = radius;
-		item._initialize(Base.getNamed(args), point);
-		return item;
-	}
-
-	return {
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createShape('circle', center, new Size(radius * 2), radius,
-					args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.min(Size.readNamed(args, 'radius'),
-						rect.getSize(true).divide(2));
-			return createShape('rectangle', rect.getCenter(true),
-					rect.getSize(true), radius, args);
-		},
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args),
-				radius = ellipse.radius;
-			return createShape('ellipse', ellipse.center, radius.multiply(2),
-					radius, args);
-		},
-
-		_readEllipse: function(args) {
-			var center,
-				radius;
-			if (Base.hasNamed(args, 'radius')) {
-				center = Point.readNamed(args, 'center');
-				radius = Size.readNamed(args, 'radius');
-			} else {
-				var rect = Rectangle.readNamed(args, 'rectangle');
-				center = rect.getCenter(true);
-				radius = rect.getSize(true).divide(2);
-			}
-			return { center: center, radius: radius };
-		}
-	};
-}});
-
-var Raster = Item.extend({
-	_class: 'Raster',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: false, handle: false },
-	_serializeFields: {
-		crossOrigin: null,
-		source: null
-	},
-	_prioritize: ['crossOrigin'],
-	_smoothing: true,
-	beans: true,
-
-	initialize: function Raster(source, position) {
-		if (!this._initialize(source,
-				position !== undefined && Point.read(arguments))) {
-			var image,
-				type = typeof source,
-				object = type === 'string'
-					? document.getElementById(source)
-					: type  === 'object'
-						? source
-						: null;
-			if (object && object !== Item.NO_INSERT) {
-				if (object.getContext || object.naturalHeight != null) {
-					image = object;
-				} else if (object) {
-					var size = Size.read(arguments);
-					if (!size.isZero()) {
-						image = CanvasProvider.getCanvas(size);
-					}
-				}
-			}
-			if (image) {
-				this.setImage(image);
-			} else {
-				this.setSource(source);
-			}
-		}
-		if (!this._size) {
-			this._size = new Size();
-			this._loaded = false;
-		}
-	},
-
-	_equals: function(item) {
-		return this.getSource() === item.getSource();
-	},
-
-	copyContent: function(source) {
-		var image = source._image,
-			canvas = source._canvas;
-		if (image) {
-			this._setImage(image);
-		} else if (canvas) {
-			var copyCanvas = CanvasProvider.getCanvas(source._size);
-			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
-			this._setImage(copyCanvas);
-		}
-		this._crossOrigin = source._crossOrigin;
-	},
-
-	getSize: function() {
-		var size = this._size;
-		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
-				this, 'setSize');
-	},
-
-	setSize: function() {
-		var size = Size.read(arguments);
-		if (!size.equals(this._size)) {
-			if (size.width > 0 && size.height > 0) {
-				var element = this.getElement();
-				this._setImage(CanvasProvider.getCanvas(size));
-				if (element)
-					this.getContext(true).drawImage(element, 0, 0,
-							size.width, size.height);
-			} else {
-				if (this._canvas)
-					CanvasProvider.release(this._canvas);
-				this._size = size.clone();
-			}
-		}
-	},
-
-	getWidth: function() {
-		return this._size ? this._size.width : 0;
-	},
-
-	setWidth: function(width) {
-		this.setSize(width, this.getHeight());
-	},
-
-	getHeight: function() {
-		return this._size ? this._size.height : 0;
-	},
-
-	setHeight: function(height) {
-		this.setSize(this.getWidth(), height);
-	},
-
-	getLoaded: function() {
-		return this._loaded;
-	},
-
-	isEmpty: function() {
-		var size = this._size;
-		return !size || size.width === 0 && size.height === 0;
-	},
-
-	getResolution: function() {
-		var matrix = this._matrix,
-			orig = new Point(0, 0).transform(matrix),
-			u = new Point(1, 0).transform(matrix).subtract(orig),
-			v = new Point(0, 1).transform(matrix).subtract(orig);
-		return new Size(
-			72 / u.getLength(),
-			72 / v.getLength()
-		);
-	},
-
-	getPpi: '#getResolution',
-
-	getImage: function() {
-		return this._image;
-	},
-
-	setImage: function(image) {
-		var that = this;
-
-		function emit(event) {
-			var view = that.getView(),
-				type = event && event.type || 'load';
-			if (view && that.responds(type)) {
-				paper = view._scope;
-				that.emit(type, new Event(event));
-			}
-		}
-
-		this._setImage(image);
-		if (this._loaded) {
-			setTimeout(emit, 0);
-		} else if (image) {
-			DomEvent.add(image, {
-				load: function(event) {
-					that._setImage(image);
-					emit(event);
-				},
-				error: emit
-			});
-		}
-	},
-
-	_setImage: function(image) {
-		if (this._canvas)
-			CanvasProvider.release(this._canvas);
-		if (image && image.getContext) {
-			this._image = null;
-			this._canvas = image;
-			this._loaded = true;
-		} else {
-			this._image = image;
-			this._canvas = null;
-			this._loaded = !!(image && image.src && image.complete);
-		}
-		this._size = new Size(
-				image ? image.naturalWidth || image.width : 0,
-				image ? image.naturalHeight || image.height : 0);
-		this._context = null;
-		this._changed(1033);
-	},
-
-	getCanvas: function() {
-		if (!this._canvas) {
-			var ctx = CanvasProvider.getContext(this._size);
-			try {
-				if (this._image)
-					ctx.drawImage(this._image, 0, 0);
-				this._canvas = ctx.canvas;
-			} catch (e) {
-				CanvasProvider.release(ctx);
-			}
-		}
-		return this._canvas;
-	},
-
-	setCanvas: '#setImage',
-
-	getContext: function(_change) {
-		if (!this._context)
-			this._context = this.getCanvas().getContext('2d');
-		if (_change) {
-			this._image = null;
-			this._changed(1025);
-		}
-		return this._context;
-	},
-
-	setContext: function(context) {
-		this._context = context;
-	},
-
-	getSource: function() {
-		var image = this._image;
-		return image && image.src || this.toDataURL();
-	},
-
-	setSource: function(src) {
-		var image = new self.Image(),
-			crossOrigin = this._crossOrigin;
-		if (crossOrigin)
-			image.crossOrigin = crossOrigin;
-		if (src)
-			image.src = src;
-		this.setImage(image);
-	},
-
-	getCrossOrigin: function() {
-		var image = this._image;
-		return image && image.crossOrigin || this._crossOrigin || '';
-	},
-
-	setCrossOrigin: function(crossOrigin) {
-		this._crossOrigin = crossOrigin;
-		var image = this._image;
-		if (image)
-			image.crossOrigin = crossOrigin;
-	},
-
-	getSmoothing: function() {
-		return this._smoothing;
-	},
-
-	setSmoothing: function(smoothing) {
-		this._smoothing = smoothing;
-		this._changed(257);
-	},
-
-	getElement: function() {
-		return this._canvas || this._loaded && this._image;
-	}
-}, {
-	beans: false,
-
-	getSubCanvas: function() {
-		var rect = Rectangle.read(arguments),
-			ctx = CanvasProvider.getContext(rect.getSize());
-		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
-				rect.width, rect.height, 0, 0, rect.width, rect.height);
-		return ctx.canvas;
-	},
-
-	getSubRaster: function() {
-		var rect = Rectangle.read(arguments),
-			raster = new Raster(Item.NO_INSERT);
-		raster._setImage(this.getSubCanvas(rect));
-		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
-		raster._matrix.prepend(this._matrix);
-		raster.insertAbove(this);
-		return raster;
-	},
-
-	toDataURL: function() {
-		var image = this._image,
-			src = image && image.src;
-		if (/^data:/.test(src))
-			return src;
-		var canvas = this.getCanvas();
-		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
-	},
-
-	drawImage: function(image ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).drawImage(image, point.x, point.y);
-	},
-
-	getAverageColor: function(object) {
-		var bounds, path;
-		if (!object) {
-			bounds = this.getBounds();
-		} else if (object instanceof PathItem) {
-			path = object;
-			bounds = object.getBounds();
-		} else if (typeof object === 'object') {
-			if ('width' in object) {
-				bounds = new Rectangle(object);
-			} else if ('x' in object) {
-				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
-			}
-		}
-		if (!bounds)
-			return null;
-		var sampleSize = 32,
-			width = Math.min(bounds.width, sampleSize),
-			height = Math.min(bounds.height, sampleSize);
-		var ctx = Raster._sampleContext;
-		if (!ctx) {
-			ctx = Raster._sampleContext = CanvasProvider.getContext(
-					new Size(sampleSize));
-		} else {
-			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
-		}
-		ctx.save();
-		var matrix = new Matrix()
-				.scale(width / bounds.width, height / bounds.height)
-				.translate(-bounds.x, -bounds.y);
-		matrix.applyToContext(ctx);
-		if (path)
-			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
-		this._matrix.applyToContext(ctx);
-		var element = this.getElement(),
-			size = this._size;
-		if (element)
-			ctx.drawImage(element, -size.width / 2, -size.height / 2);
-		ctx.restore();
-		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
-				Math.ceil(height)).data,
-			channels = [0, 0, 0],
-			total = 0;
-		for (var i = 0, l = pixels.length; i < l; i += 4) {
-			var alpha = pixels[i + 3];
-			total += alpha;
-			alpha /= 255;
-			channels[0] += pixels[i] * alpha;
-			channels[1] += pixels[i + 1] * alpha;
-			channels[2] += pixels[i + 2] * alpha;
-		}
-		for (var i = 0; i < 3; i++)
-			channels[i] /= total;
-		return total ? Color.read(channels) : null;
-	},
-
-	getPixel: function() {
-		var point = Point.read(arguments);
-		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
-		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
-				data[3] / 255);
-	},
-
-	setPixel: function() {
-		var args = arguments,
-			point = Point.read(args),
-			color = Color.read(args),
-			components = color._convert('rgb'),
-			alpha = color._alpha,
-			ctx = this.getContext(true),
-			imageData = ctx.createImageData(1, 1),
-			data = imageData.data;
-		data[0] = components[0] * 255;
-		data[1] = components[1] * 255;
-		data[2] = components[2] * 255;
-		data[3] = alpha != null ? alpha * 255 : 255;
-		ctx.putImageData(imageData, point.x, point.y);
-	},
-
-	clear: function() {
-		var size = this._size;
-		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
-	},
-
-	createImageData: function() {
-		var size = Size.read(arguments);
-		return this.getContext().createImageData(size.width, size.height);
-	},
-
-	getImageData: function() {
-		var rect = Rectangle.read(arguments);
-		if (rect.isEmpty())
-			rect = new Rectangle(this._size);
-		return this.getContext().getImageData(rect.x, rect.y,
-				rect.width, rect.height);
-	},
-
-	setImageData: function(data ) {
-		var point = Point.read(arguments, 1);
-		this.getContext(true).putImageData(data, point.x, point.y);
-	},
-
-	_getBounds: function(matrix, options) {
-		var rect = new Rectangle(this._size).setCenter(0, 0);
-		return matrix ? matrix._transformBounds(rect) : rect;
-	},
-
-	_hitTestSelf: function(point) {
-		if (this._contains(point)) {
-			var that = this;
-			return new HitResult('pixel', that, {
-				offset: point.add(that._size.divide(2)).round(),
-				color: {
-					get: function() {
-						return that.getPixel(this.offset);
-					}
-				}
-			});
-		}
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		var element = this.getElement();
-		if (element && element.width > 0 && element.height > 0) {
-			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
-
-			this._setStyles(ctx, param, viewMatrix);
-
-			DomElement.setPrefixed(
-				ctx, 'imageSmoothingEnabled', this._smoothing
-			);
-
-			ctx.drawImage(element,
-					-this._size.width / 2, -this._size.height / 2);
-		}
-	},
-
-	_canComposite: function() {
-		return true;
-	}
-});
-
-var SymbolItem = Item.extend({
-	_class: 'SymbolItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_boundsOptions: { stroke: true },
-	_serializeFields: {
-		symbol: null
-	},
-
-	initialize: function SymbolItem(arg0, arg1) {
-		if (!this._initialize(arg0,
-				arg1 !== undefined && Point.read(arguments, 1)))
-			this.setDefinition(arg0 instanceof SymbolDefinition ?
-					arg0 : new SymbolDefinition(arg0));
-	},
-
-	_equals: function(item) {
-		return this._definition === item._definition;
-	},
-
-	copyContent: function(source) {
-		this.setDefinition(source._definition);
-	},
-
-	getDefinition: function() {
-		return this._definition;
-	},
-
-	setDefinition: function(definition) {
-		this._definition = definition;
-		this._changed(9);
-	},
-
-	getSymbol: '#getDefinition',
-	setSymbol: '#setDefinition',
-
-	isEmpty: function() {
-		return this._definition._item.isEmpty();
-	},
-
-	_getBounds: function(matrix, options) {
-		var item = this._definition._item;
-		return item._getCachedBounds(item._matrix.prepended(matrix), options);
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix) {
-		var opts = options.extend({ all: false });
-		var res = this._definition._item._hitTest(point, opts, viewMatrix);
-		if (res)
-			res.item = this;
-		return res;
-	},
-
-	_draw: function(ctx, param) {
-		this._definition._item.draw(ctx, param);
-	}
-
-});
-
-var SymbolDefinition = Base.extend({
-	_class: 'SymbolDefinition',
-
-	initialize: function SymbolDefinition(item, dontCenter) {
-		this._id = UID.get();
-		this.project = paper.project;
-		if (item)
-			this.setItem(item, dontCenter);
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._class, this._item],
-					options, false, dictionary);
-		});
-	},
-
-	_changed: function(flags) {
-		if (flags & 8)
-			Item._clearBoundsCache(this);
-		if (flags & 1)
-			this.project._changed(flags);
-	},
-
-	getItem: function() {
-		return this._item;
-	},
-
-	setItem: function(item, _dontCenter) {
-		if (item._symbol)
-			item = item.clone();
-		if (this._item)
-			this._item._symbol = null;
-		this._item = item;
-		item.remove();
-		item.setSelected(false);
-		if (!_dontCenter)
-			item.setPosition(new Point());
-		item._symbol = this;
-		this._changed(9);
-	},
-
-	getDefinition: '#getItem',
-	setDefinition: '#setItem',
-
-	place: function(position) {
-		return new SymbolItem(this, position);
-	},
-
-	clone: function() {
-		return new SymbolDefinition(this._item.clone(false));
-	},
-
-	equals: function(symbol) {
-		return symbol === this
-				|| symbol && this._item.equals(symbol._item)
-				|| false;
-	}
-});
-
-var HitResult = Base.extend({
-	_class: 'HitResult',
-
-	initialize: function HitResult(type, item, values) {
-		this.type = type;
-		this.item = item;
-		if (values)
-			this.inject(values);
-	},
-
-	statics: {
-		getOptions: function(args) {
-			var options = args && Base.read(args);
-			return new Base({
-				type: null,
-				tolerance: paper.settings.hitTolerance,
-				fill: !options,
-				stroke: !options,
-				segments: !options,
-				handles: false,
-				ends: false,
-				position: false,
-				center: false,
-				bounds: false,
-				guides: false,
-				selected: false
-			}, options);
-		}
-	}
-});
-
-var Segment = Base.extend({
-	_class: 'Segment',
-	beans: true,
-	_selection: 0,
-
-	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
-		var count = arguments.length,
-			point, handleIn, handleOut, selection;
-		if (count > 0) {
-			if (arg0 == null || typeof arg0 === 'object') {
-				if (count === 1 && arg0 && 'point' in arg0) {
-					point = arg0.point;
-					handleIn = arg0.handleIn;
-					handleOut = arg0.handleOut;
-					selection = arg0.selection;
-				} else {
-					point = arg0;
-					handleIn = arg1;
-					handleOut = arg2;
-					selection = arg3;
-				}
-			} else {
-				point = [ arg0, arg1 ];
-				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
-				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
-			}
-		}
-		new SegmentPoint(point, this, '_point');
-		new SegmentPoint(handleIn, this, '_handleIn');
-		new SegmentPoint(handleOut, this, '_handleOut');
-		if (selection)
-			this.setSelection(selection);
-	},
-
-	_serialize: function(options, dictionary) {
-		var point = this._point,
-			selection = this._selection,
-			obj = selection || this.hasHandles()
-					? [point, this._handleIn, this._handleOut]
-					: point;
-		if (selection)
-			obj.push(selection);
-		return Base.serialize(obj, options, true, dictionary);
-	},
-
-	_changed: function(point) {
-		var path = this._path;
-		if (!path)
-			return;
-		var curves = path._curves,
-			index = this._index,
-			curve;
-		if (curves) {
-			if ((!point || point === this._point || point === this._handleIn)
-					&& (curve = index > 0 ? curves[index - 1] : path._closed
-						? curves[curves.length - 1] : null))
-				curve._changed();
-			if ((!point || point === this._point || point === this._handleOut)
-					&& (curve = curves[index]))
-				curve._changed();
-		}
-		path._changed(41);
-	},
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	setPoint: function() {
-		this._point.set(Point.read(arguments));
-	},
-
-	getHandleIn: function() {
-		return this._handleIn;
-	},
-
-	setHandleIn: function() {
-		this._handleIn.set(Point.read(arguments));
-	},
-
-	getHandleOut: function() {
-		return this._handleOut;
-	},
-
-	setHandleOut: function() {
-		this._handleOut.set(Point.read(arguments));
-	},
-
-	hasHandles: function() {
-		return !this._handleIn.isZero() || !this._handleOut.isZero();
-	},
-
-	isSmooth: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut;
-		return !handleIn.isZero() && !handleOut.isZero()
-				&& handleIn.isCollinear(handleOut);
-	},
-
-	clearHandles: function() {
-		this._handleIn._set(0, 0);
-		this._handleOut._set(0, 0);
-	},
-
-	getSelection: function() {
-		return this._selection;
-	},
-
-	setSelection: function(selection) {
-		var oldSelection = this._selection,
-			path = this._path;
-		this._selection = selection = selection || 0;
-		if (path && selection !== oldSelection) {
-			path._updateSelection(this, oldSelection, selection);
-			path._changed(257);
-		}
-	},
-
-	_changeSelection: function(flag, selected) {
-		var selection = this._selection;
-		this.setSelection(selected ? selection | flag : selection & ~flag);
-	},
-
-	isSelected: function() {
-		return !!(this._selection & 7);
-	},
-
-	setSelected: function(selected) {
-		this._changeSelection(7, selected);
-	},
-
-	getIndex: function() {
-		return this._index !== undefined ? this._index : null;
-	},
-
-	getPath: function() {
-		return this._path || null;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			index = this._index;
-		if (path) {
-			if (index > 0 && !path._closed
-					&& index === path._segments.length - 1)
-				index--;
-			return path.getCurves()[index] || null;
-		}
-		return null;
-	},
-
-	getLocation: function() {
-		var curve = this.getCurve();
-		return curve
-				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
-				: null;
-	},
-
-	getNext: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index + 1]
-				|| this._path._closed && segments[0]) || null;
-	},
-
-	smooth: function(options, _first, _last) {
-		var opts = options || {},
-			type = opts.type,
-			factor = opts.factor,
-			prev = this.getPrevious(),
-			next = this.getNext(),
-			p0 = (prev || this)._point,
-			p1 = this._point,
-			p2 = (next || this)._point,
-			d1 = p0.getDistance(p1),
-			d2 = p1.getDistance(p2);
-		if (!type || type === 'catmull-rom') {
-			var a = factor === undefined ? 0.5 : factor,
-				d1_a = Math.pow(d1, a),
-				d1_2a = d1_a * d1_a,
-				d2_a = Math.pow(d2, a),
-				d2_2a = d2_a * d2_a;
-			if (!_first && prev) {
-				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
-					N = 3 * d2_a * (d2_a + d1_a);
-				this.setHandleIn(N !== 0
-					? new Point(
-						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
-						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
-					: new Point());
-			}
-			if (!_last && next) {
-				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
-					N = 3 * d1_a * (d1_a + d2_a);
-				this.setHandleOut(N !== 0
-					? new Point(
-						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
-						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
-					: new Point());
-			}
-		} else if (type === 'geometric') {
-			if (prev && next) {
-				var vector = p0.subtract(p2),
-					t = factor === undefined ? 0.4 : factor,
-					k = t * d1 / (d1 + d2);
-				if (!_first)
-					this.setHandleIn(vector.multiply(k));
-				if (!_last)
-					this.setHandleOut(vector.multiply(k - t));
-			}
-		} else {
-			throw new Error('Smoothing method \'' + type + '\' not supported.');
-		}
-	},
-
-	getPrevious: function() {
-		var segments = this._path && this._path._segments;
-		return segments && (segments[this._index - 1]
-				|| this._path._closed && segments[segments.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._index === path._segments.length - 1 || false;
-	},
-
-	reverse: function() {
-		var handleIn = this._handleIn,
-			handleOut = this._handleOut,
-			tmp = handleIn.clone();
-		handleIn.set(handleOut);
-		handleOut.set(tmp);
-	},
-
-	reversed: function() {
-		return new Segment(this._point, this._handleOut, this._handleIn);
-	},
-
-	remove: function() {
-		return this._path ? !!this._path.removeSegment(this._index) : false;
-	},
-
-	clone: function() {
-		return new Segment(this._point, this._handleIn, this._handleOut);
-	},
-
-	equals: function(segment) {
-		return segment === this || segment && this._class === segment._class
-				&& this._point.equals(segment._point)
-				&& this._handleIn.equals(segment._handleIn)
-				&& this._handleOut.equals(segment._handleOut)
-				|| false;
-	},
-
-	toString: function() {
-		var parts = [ 'point: ' + this._point ];
-		if (!this._handleIn.isZero())
-			parts.push('handleIn: ' + this._handleIn);
-		if (!this._handleOut.isZero())
-			parts.push('handleOut: ' + this._handleOut);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	transform: function(matrix) {
-		this._transformCoordinates(matrix, new Array(6), true);
-		this._changed();
-	},
-
-	interpolate: function(from, to, factor) {
-		var u = 1 - factor,
-			v = factor,
-			point1 = from._point,
-			point2 = to._point,
-			handleIn1 = from._handleIn,
-			handleIn2 = to._handleIn,
-			handleOut2 = to._handleOut,
-			handleOut1 = from._handleOut;
-		this._point._set(
-				u * point1._x + v * point2._x,
-				u * point1._y + v * point2._y, true);
-		this._handleIn._set(
-				u * handleIn1._x + v * handleIn2._x,
-				u * handleIn1._y + v * handleIn2._y, true);
-		this._handleOut._set(
-				u * handleOut1._x + v * handleOut2._x,
-				u * handleOut1._y + v * handleOut2._y, true);
-		this._changed();
-	},
-
-	_transformCoordinates: function(matrix, coords, change) {
-		var point = this._point,
-			handleIn = !change || !this._handleIn.isZero()
-					? this._handleIn : null,
-			handleOut = !change || !this._handleOut.isZero()
-					? this._handleOut : null,
-			x = point._x,
-			y = point._y,
-			i = 2;
-		coords[0] = x;
-		coords[1] = y;
-		if (handleIn) {
-			coords[i++] = handleIn._x + x;
-			coords[i++] = handleIn._y + y;
-		}
-		if (handleOut) {
-			coords[i++] = handleOut._x + x;
-			coords[i++] = handleOut._y + y;
-		}
-		if (matrix) {
-			matrix._transformCoordinates(coords, coords, i / 2);
-			x = coords[0];
-			y = coords[1];
-			if (change) {
-				point._x = x;
-				point._y = y;
-				i = 2;
-				if (handleIn) {
-					handleIn._x = coords[i++] - x;
-					handleIn._y = coords[i++] - y;
-				}
-				if (handleOut) {
-					handleOut._x = coords[i++] - x;
-					handleOut._y = coords[i++] - y;
-				}
-			} else {
-				if (!handleIn) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-				if (!handleOut) {
-					coords[i++] = x;
-					coords[i++] = y;
-				}
-			}
-		}
-		return coords;
-	}
-});
-
-var SegmentPoint = Point.extend({
-	initialize: function SegmentPoint(point, owner, key) {
-		var x, y,
-			selected;
-		if (!point) {
-			x = y = 0;
-		} else if ((x = point[0]) !== undefined) {
-			y = point[1];
-		} else {
-			var pt = point;
-			if ((x = pt.x) === undefined) {
-				pt = Point.read(arguments);
-				x = pt.x;
-			}
-			y = pt.y;
-			selected = pt.selected;
-		}
-		this._x = x;
-		this._y = y;
-		this._owner = owner;
-		owner[key] = this;
-		if (selected)
-			this.setSelected(true);
-	},
-
-	_set: function(x, y) {
-		this._x = x;
-		this._y = y;
-		this._owner._changed(this);
-		return this;
-	},
-
-	getX: function() {
-		return this._x;
-	},
-
-	setX: function(x) {
-		this._x = x;
-		this._owner._changed(this);
-	},
-
-	getY: function() {
-		return this._y;
-	},
-
-	setY: function(y) {
-		this._y = y;
-		this._owner._changed(this);
-	},
-
-	isZero: function() {
-		var isZero = Numerical.isZero;
-		return isZero(this._x) && isZero(this._y);
-	},
-
-	isSelected: function() {
-		return !!(this._owner._selection & this._getSelection());
-	},
-
-	setSelected: function(selected) {
-		this._owner._changeSelection(this._getSelection(), selected);
-	},
-
-	_getSelection: function() {
-		var owner = this._owner;
-		return this === owner._point ? 1
-			: this === owner._handleIn ? 2
-			: this === owner._handleOut ? 4
-			: 0;
-	}
-});
-
-var Curve = Base.extend({
-	_class: 'Curve',
-	beans: true,
-
-	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
-		var count = arguments.length,
-			seg1, seg2,
-			point1, point2,
-			handle1, handle2;
-		if (count === 3) {
-			this._path = arg0;
-			seg1 = arg1;
-			seg2 = arg2;
-		} else if (!count) {
-			seg1 = new Segment();
-			seg2 = new Segment();
-		} else if (count === 1) {
-			if ('segment1' in arg0) {
-				seg1 = new Segment(arg0.segment1);
-				seg2 = new Segment(arg0.segment2);
-			} else if ('point1' in arg0) {
-				point1 = arg0.point1;
-				handle1 = arg0.handle1;
-				handle2 = arg0.handle2;
-				point2 = arg0.point2;
-			} else if (Array.isArray(arg0)) {
-				point1 = [arg0[0], arg0[1]];
-				point2 = [arg0[6], arg0[7]];
-				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
-				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
-			}
-		} else if (count === 2) {
-			seg1 = new Segment(arg0);
-			seg2 = new Segment(arg1);
-		} else if (count === 4) {
-			point1 = arg0;
-			handle1 = arg1;
-			handle2 = arg2;
-			point2 = arg3;
-		} else if (count === 8) {
-			point1 = [arg0, arg1];
-			point2 = [arg6, arg7];
-			handle1 = [arg2 - arg0, arg3 - arg1];
-			handle2 = [arg4 - arg6, arg5 - arg7];
-		}
-		this._segment1 = seg1 || new Segment(point1, null, handle1);
-		this._segment2 = seg2 || new Segment(point2, handle2, null);
-	},
-
-	_serialize: function(options, dictionary) {
-		return Base.serialize(this.hasHandles()
-				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
-					this.getPoint2()]
-				: [this.getPoint1(), this.getPoint2()],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		this._length = this._bounds = undefined;
-	},
-
-	clone: function() {
-		return new Curve(this._segment1, this._segment2);
-	},
-
-	toString: function() {
-		var parts = [ 'point1: ' + this._segment1._point ];
-		if (!this._segment1._handleOut.isZero())
-			parts.push('handle1: ' + this._segment1._handleOut);
-		if (!this._segment2._handleIn.isZero())
-			parts.push('handle2: ' + this._segment2._handleIn);
-		parts.push('point2: ' + this._segment2._point);
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	classify: function() {
-		return Curve.classify(this.getValues());
-	},
-
-	remove: function() {
-		var removed = false;
-		if (this._path) {
-			var segment2 = this._segment2,
-				handleOut = segment2._handleOut;
-			removed = segment2.remove();
-			if (removed)
-				this._segment1._handleOut.set(handleOut);
-		}
-		return removed;
-	},
-
-	getPoint1: function() {
-		return this._segment1._point;
-	},
-
-	setPoint1: function() {
-		this._segment1._point.set(Point.read(arguments));
-	},
-
-	getPoint2: function() {
-		return this._segment2._point;
-	},
-
-	setPoint2: function() {
-		this._segment2._point.set(Point.read(arguments));
-	},
-
-	getHandle1: function() {
-		return this._segment1._handleOut;
-	},
-
-	setHandle1: function() {
-		this._segment1._handleOut.set(Point.read(arguments));
-	},
-
-	getHandle2: function() {
-		return this._segment2._handleIn;
-	},
-
-	setHandle2: function() {
-		this._segment2._handleIn.set(Point.read(arguments));
-	},
-
-	getSegment1: function() {
-		return this._segment1;
-	},
-
-	getSegment2: function() {
-		return this._segment2;
-	},
-
-	getPath: function() {
-		return this._path;
-	},
-
-	getIndex: function() {
-		return this._segment1._index;
-	},
-
-	getNext: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index + 1]
-				|| this._path._closed && curves[0]) || null;
-	},
-
-	getPrevious: function() {
-		var curves = this._path && this._path._curves;
-		return curves && (curves[this._segment1._index - 1]
-				|| this._path._closed && curves[curves.length - 1]) || null;
-	},
-
-	isFirst: function() {
-		return !this._segment1._index;
-	},
-
-	isLast: function() {
-		var path = this._path;
-		return path && this._segment1._index === path._curves.length - 1
-				|| false;
-	},
-
-	isSelected: function() {
-		return this.getPoint1().isSelected()
-				&& this.getHandle1().isSelected()
-				&& this.getHandle2().isSelected()
-				&& this.getPoint2().isSelected();
-	},
-
-	setSelected: function(selected) {
-		this.getPoint1().setSelected(selected);
-		this.getHandle1().setSelected(selected);
-		this.getHandle2().setSelected(selected);
-		this.getPoint2().setSelected(selected);
-	},
-
-	getValues: function(matrix) {
-		return Curve.getValues(this._segment1, this._segment2, matrix);
-	},
-
-	getPoints: function() {
-		var coords = this.getValues(),
-			points = [];
-		for (var i = 0; i < 8; i += 2)
-			points.push(new Point(coords[i], coords[i + 1]));
-		return points;
-	}
-}, {
-	getLength: function() {
-		if (this._length == null)
-			this._length = Curve.getLength(this.getValues(), 0, 1);
-		return this._length;
-	},
-
-	getArea: function() {
-		return Curve.getArea(this.getValues());
-	},
-
-	getLine: function() {
-		return new Line(this._segment1._point, this._segment2._point);
-	},
-
-	getPart: function(from, to) {
-		return new Curve(Curve.getPart(this.getValues(), from, to));
-	},
-
-	getPartLength: function(from, to) {
-		return Curve.getLength(this.getValues(), from, to);
-	},
-
-	divideAt: function(location) {
-		return this.divideAtTime(location && location.curve === this
-				? location.time : this.getTimeAt(location));
-	},
-
-	divideAtTime: function(time, _setHandles) {
-		var tMin = 1e-8,
-			tMax = 1 - tMin,
-			res = null;
-		if (time >= tMin && time <= tMax) {
-			var parts = Curve.subdivide(this.getValues(), time),
-				left = parts[0],
-				right = parts[1],
-				setHandles = _setHandles || this.hasHandles(),
-				seg1 = this._segment1,
-				seg2 = this._segment2,
-				path = this._path;
-			if (setHandles) {
-				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
-				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
-			}
-			var x = left[6], y = left[7],
-				segment = new Segment(new Point(x, y),
-						setHandles && new Point(left[4] - x, left[5] - y),
-						setHandles && new Point(right[2] - x, right[3] - y));
-			if (path) {
-				path.insert(seg1._index + 1, segment);
-				res = this.getNext();
-			} else {
-				this._segment2 = segment;
-				this._changed();
-				res = new Curve(segment, seg2);
-			}
-		}
-		return res;
-	},
-
-	splitAt: function(location) {
-		var path = this._path;
-		return path ? path.splitAt(location) : null;
-	},
-
-	splitAtTime: function(time) {
-		return this.splitAt(this.getLocationAtTime(time));
-	},
-
-	divide: function(offset, isTime) {
-		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	split: function(offset, isTime) {
-		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
-				: this.getTimeAt(offset));
-	},
-
-	reversed: function() {
-		return new Curve(this._segment2.reversed(), this._segment1.reversed());
-	},
-
-	clearHandles: function() {
-		this._segment1._handleOut._set(0, 0);
-		this._segment2._handleIn._set(0, 0);
-	},
-
-statics: {
-	getValues: function(segment1, segment2, matrix, straight) {
-		var p1 = segment1._point,
-			h1 = segment1._handleOut,
-			h2 = segment2._handleIn,
-			p2 = segment2._point,
-			x1 = p1.x, y1 = p1.y,
-			x2 = p2.x, y2 = p2.y,
-			values = straight
-				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
-				: [
-					x1, y1,
-					x1 + h1._x, y1 + h1._y,
-					x2 + h2._x, y2 + h2._y,
-					x2, y2
-				];
-		if (matrix)
-			matrix._transformCoordinates(values, values, 4);
-		return values;
-	},
-
-	subdivide: function(v, t) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		if (t === undefined)
-			t = 0.5;
-		var u = 1 - t,
-			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
-			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
-			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
-			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
-			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
-			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
-		return [
-			[x0, y0, x4, y4, x7, y7, x9, y9],
-			[x9, y9, x8, y8, x6, y6, x3, y3]
-		];
-	},
-
-	getMonoCurves: function(v, dir) {
-		var curves = [],
-			io = dir ? 0 : 1,
-			o0 = v[io + 0],
-			o1 = v[io + 2],
-			o2 = v[io + 4],
-			o3 = v[io + 6];
-		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
-				|| Curve.isStraight(v)) {
-			curves.push(v);
-		} else {
-			var a = 3 * (o1 - o2) - o0 + o3,
-				b = 2 * (o0 + o2) - 4 * o1,
-				c = o1 - o0,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [],
-				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
-			if (!n) {
-				curves.push(v);
-			} else {
-				roots.sort();
-				var t = roots[0],
-					parts = Curve.subdivide(v, t);
-				curves.push(parts[0]);
-				if (n > 1) {
-					t = (roots[1] - t) / (1 - t);
-					parts = Curve.subdivide(parts[1], t);
-					curves.push(parts[0]);
-				}
-				curves.push(parts[1]);
-			}
-		}
-		return curves;
-	},
-
-	solveCubic: function (v, coord, val, roots, min, max) {
-		var v0 = v[coord],
-			v1 = v[coord + 2],
-			v2 = v[coord + 4],
-			v3 = v[coord + 6],
-			res = 0;
-		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
-				v0 > val && v3 > val && v1 > val && v2 > val)) {
-			var c = 3 * (v1 - v0),
-				b = 3 * (v2 - v1) - c,
-				a = v3 - v0 - c - b;
-			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
-		}
-		return res;
-	},
-
-	getTimeOf: function(v, point) {
-		var p0 = new Point(v[0], v[1]),
-			p3 = new Point(v[6], v[7]),
-			epsilon = 1e-12,
-			geomEpsilon = 1e-7,
-			t = point.isClose(p0, epsilon) ? 0
-			  : point.isClose(p3, epsilon) ? 1
-			  : null;
-		if (t === null) {
-			var coords = [point.x, point.y],
-				roots = [];
-			for (var c = 0; c < 2; c++) {
-				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
-				for (var i = 0; i < count; i++) {
-					var u = roots[i];
-					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
-						return u;
-				}
-			}
-		}
-		return point.isClose(p0, geomEpsilon) ? 0
-			 : point.isClose(p3, geomEpsilon) ? 1
-			 : null;
-	},
-
-	getNearestTime: function(v, point) {
-		if (Curve.isStraight(v)) {
-			var x0 = v[0], y0 = v[1],
-				x3 = v[6], y3 = v[7],
-				vx = x3 - x0, vy = y3 - y0,
-				det = vx * vx + vy * vy;
-			if (det === 0)
-				return 0;
-			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
-			return u < 1e-12 ? 0
-				 : u > 0.999999999999 ? 1
-				 : Curve.getTimeOf(v,
-					new Point(x0 + u * vx, y0 + u * vy));
-		}
-
-		var count = 100,
-			minDist = Infinity,
-			minT = 0;
-
-		function refine(t) {
-			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(Curve.getPoint(v, t), true);
-				if (dist < minDist) {
-					minDist = dist;
-					minT = t;
-					return true;
-				}
-			}
-		}
-
-		for (var i = 0; i <= count; i++)
-			refine(i / count);
-
-		var step = 1 / (count * 2);
-		while (step > 1e-8) {
-			if (!refine(minT - step) && !refine(minT + step))
-				step /= 2;
-		}
-		return minT;
-	},
-
-	getPart: function(v, from, to) {
-		var flip = from > to;
-		if (flip) {
-			var tmp = from;
-			from = to;
-			to = tmp;
-		}
-		if (from > 0)
-			v = Curve.subdivide(v, from)[1];
-		if (to < 1)
-			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
-		return flip
-				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
-				: v;
-	},
-
-	isFlatEnough: function(v, flatness) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			ux = 3 * x1 - 2 * x0 - x3,
-			uy = 3 * y1 - 2 * y0 - y3,
-			vx = 3 * x2 - 2 * x3 - x0,
-			vy = 3 * y2 - 2 * y3 - y0;
-		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
-				<= 16 * flatness * flatness;
-	},
-
-	getArea: function(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7];
-		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
-				+ y1 * (x0 - x2) - x1 * (y0 - y2)
-				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
-	},
-
-	getBounds: function(v) {
-		var min = v.slice(0, 2),
-			max = min.slice(),
-			roots = [0, 0];
-		for (var i = 0; i < 2; i++)
-			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
-					i, 0, min, max, roots);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
-		function add(value, padding) {
-			var left = value - padding,
-				right = value + padding;
-			if (left < min[coord])
-				min[coord] = left;
-			if (right > max[coord])
-				max[coord] = right;
-		}
-
-		padding /= 2;
-		var minPad = min[coord] - padding,
-			maxPad = max[coord] + padding;
-		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
-				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
-			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
-				add(v0, padding);
-				add(v3, padding);
-			} else {
-				var a = 3 * (v1 - v2) - v0 + v3,
-					b = 2 * (v0 + v2) - 4 * v1,
-					c = v1 - v0,
-					count = Numerical.solveQuadratic(a, b, c, roots),
-					tMin = 1e-8,
-					tMax = 1 - tMin;
-				add(v3, 0);
-				for (var i = 0; i < count; i++) {
-					var t = roots[i],
-						u = 1 - t;
-					if (tMin <= t && t <= tMax)
-						add(u * u * u * v0
-							+ 3 * u * u * t * v1
-							+ 3 * u * t * t * v2
-							+ t * t * t * v3,
-							padding);
-				}
-			}
-		}
-	}
-}}, Base.each(
-	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
-	function(name) {
-		this[name] = function() {
-			if (!this._bounds)
-				this._bounds = {};
-			var bounds = this._bounds[name];
-			if (!bounds) {
-				bounds = this._bounds[name] = Path[name](
-						[this._segment1, this._segment2], false, this._path);
-			}
-			return bounds.clone();
-		};
-	},
-{
-
-}), Base.each({
-	isStraight: function(p1, h1, h2, p2) {
-		if (h1.isZero() && h2.isZero()) {
-			return true;
-		} else {
-			var v = p2.subtract(p1);
-			if (v.isZero()) {
-				return false;
-			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
-				var l = new Line(p1, p2),
-					epsilon = 1e-7;
-				if (l.getDistance(p1.add(h1)) < epsilon &&
-					l.getDistance(p2.add(h2)) < epsilon) {
-					var div = v.dot(v),
-						s1 = v.dot(h1) / div,
-						s2 = v.dot(h2) / div;
-					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
-				}
-			}
-		}
-		return false;
-	},
-
-	isLinear: function(p1, h1, h2, p2) {
-		var third = p2.subtract(p1).divide(3);
-		return h1.equals(third) && h2.negate().equals(third);
-	}
-}, function(test, name) {
-	this[name] = function(epsilon) {
-		var seg1 = this._segment1,
-			seg2 = this._segment2;
-		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
-				epsilon);
-	};
-
-	this.statics[name] = function(v, epsilon) {
-		var x0 = v[0], y0 = v[1],
-			x3 = v[6], y3 = v[7];
-		return test(
-				new Point(x0, y0),
-				new Point(v[2] - x0, v[3] - y0),
-				new Point(v[4] - x3, v[5] - y3),
-				new Point(x3, y3), epsilon);
-	};
-}, {
-	statics: {},
-
-	hasHandles: function() {
-		return !this._segment1._handleOut.isZero()
-				|| !this._segment2._handleIn.isZero();
-	},
-
-	hasLength: function(epsilon) {
-		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
-				&& this.getLength() > (epsilon || 0);
-	},
-
-	isCollinear: function(curve) {
-		return curve && this.isStraight() && curve.isStraight()
-				&& this.getLine().isCollinear(curve.getLine());
-	},
-
-	isHorizontal: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
-				< 1e-8;
-	},
-
-	isVertical: function() {
-		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
-				< 1e-8;
-	}
-}), {
-	beans: false,
-
-	getLocationAt: function(offset, _isTime) {
-		return this.getLocationAtTime(
-				_isTime ? offset : this.getTimeAt(offset));
-	},
-
-	getLocationAtTime: function(t) {
-		return t != null && t >= 0 && t <= 1
-				? new CurveLocation(this, t)
-				: null;
-	},
-
-	getTimeAt: function(offset, start) {
-		return Curve.getTimeAt(this.getValues(), offset, start);
-	},
-
-	getParameterAt: '#getTimeAt',
-
-	getTimesWithTangent: function () {
-		var tangent = Point.read(arguments);
-		return tangent.isZero()
-				? []
-				: Curve.getTimesWithTangent(this.getValues(), tangent);
-	},
-
-	getOffsetAtTime: function(t) {
-		return this.getPartLength(0, t);
-	},
-
-	getLocationOf: function() {
-		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getTimeOf: function() {
-		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
-	},
-
-	getParameterOf: '#getTimeOf',
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			values = this.getValues(),
-			t = Curve.getNearestTime(values, point),
-			pt = Curve.getPoint(values, t);
-		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	}
-
-},
-new function() {
-	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
-		'getWeightedNormal', 'getCurvature'];
-	return Base.each(methods,
-		function(name) {
-			this[name + 'At'] = function(location, _isTime) {
-				var values = this.getValues();
-				return Curve[name](values, _isTime ? location
-						: Curve.getTimeAt(values, location));
-			};
-
-			this[name + 'AtTime'] = function(time) {
-				return Curve[name](this.getValues(), time);
-			};
-		}, {
-			statics: {
-				_evaluateMethods: methods
-			}
-		}
-	);
-},
-new function() {
-
-	function getLengthIntegrand(v) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-
-			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
-			bx = 6 * (x0 + x2) - 12 * x1,
-			cx = 3 * (x1 - x0),
-
-			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
-			by = 6 * (y0 + y2) - 12 * y1,
-			cy = 3 * (y1 - y0);
-
-		return function(t) {
-			var dx = (ax * t + bx) * t + cx,
-				dy = (ay * t + by) * t + cy;
-			return Math.sqrt(dx * dx + dy * dy);
-		};
-	}
-
-	function getIterations(a, b) {
-		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
-	}
-
-	function evaluate(v, t, type, normalized) {
-		if (t == null || t < 0 || t > 1)
-			return null;
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			isZero = Numerical.isZero;
-		if (isZero(x1 - x0) && isZero(y1 - y0)) {
-			x1 = x0;
-			y1 = y0;
-		}
-		if (isZero(x2 - x3) && isZero(y2 - y3)) {
-			x2 = x3;
-			y2 = y3;
-		}
-		var cx = 3 * (x1 - x0),
-			bx = 3 * (x2 - x1) - cx,
-			ax = x3 - x0 - cx - bx,
-			cy = 3 * (y1 - y0),
-			by = 3 * (y2 - y1) - cy,
-			ay = y3 - y0 - cy - by,
-			x, y;
-		if (type === 0) {
-			x = t === 0 ? x0 : t === 1 ? x3
-					: ((ax * t + bx) * t + cx) * t + x0;
-			y = t === 0 ? y0 : t === 1 ? y3
-					: ((ay * t + by) * t + cy) * t + y0;
-		} else {
-			var tMin = 1e-8,
-				tMax = 1 - tMin;
-			if (t < tMin) {
-				x = cx;
-				y = cy;
-			} else if (t > tMax) {
-				x = 3 * (x3 - x2);
-				y = 3 * (y3 - y2);
-			} else {
-				x = (3 * ax * t + 2 * bx) * t + cx;
-				y = (3 * ay * t + 2 * by) * t + cy;
-			}
-			if (normalized) {
-				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
-					x = x2 - x1;
-					y = y2 - y1;
-				}
-				var len = Math.sqrt(x * x + y * y);
-				if (len) {
-					x /= len;
-					y /= len;
-				}
-			}
-			if (type === 3) {
-				var x2 = 6 * ax * t + 2 * bx,
-					y2 = 6 * ay * t + 2 * by,
-					d = Math.pow(x * x + y * y, 3 / 2);
-				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
-				y = 0;
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
-	}
-
-	return { statics: {
-
-		classify: function(v) {
-
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
-				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
-				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
-				d3 = 3 * a3,
-				d2 = d3 - a2,
-				d1 = d2 - a2 + a1,
-				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
-				s = l !== 0 ? 1 / l : 0,
-				isZero = Numerical.isZero,
-				serpentine = 'serpentine';
-			d1 *= s;
-			d2 *= s;
-			d3 *= s;
-
-			function type(type, t1, t2) {
-				var hasRoots = t1 !== undefined,
-					t1Ok = hasRoots && t1 > 0 && t1 < 1,
-					t2Ok = hasRoots && t2 > 0 && t2 < 1;
-				if (hasRoots && (!(t1Ok || t2Ok)
-						|| type === 'loop' && !(t1Ok && t2Ok))) {
-					type = 'arch';
-					t1Ok = t2Ok = false;
-				}
-				return {
-					type: type,
-					roots: t1Ok || t2Ok
-							? t1Ok && t2Ok
-								? t1 < t2 ? [t1, t2] : [t2, t1]
-								: [t1Ok ? t1 : t2]
-							: null
-				};
-			}
-
-			if (isZero(d1)) {
-				return isZero(d2)
-						? type(isZero(d3) ? 'line' : 'quadratic')
-						: type(serpentine, d3 / (3 * d2));
-			}
-			var d = 3 * d2 * d2 - 4 * d1 * d3;
-			if (isZero(d)) {
-				return type('cusp', d2 / (2 * d1));
-			}
-			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
-				f2 = 2 * d1;
-			return type(d > 0 ? serpentine : 'loop',
-					(d2 + f1) / f2,
-					(d2 - f1) / f2);
-		},
-
-		getLength: function(v, a, b, ds) {
-			if (a === undefined)
-				a = 0;
-			if (b === undefined)
-				b = 1;
-			if (Curve.isStraight(v)) {
-				var c = v;
-				if (b < 1) {
-					c = Curve.subdivide(c, b)[0];
-					a /= b;
-				}
-				if (a > 0) {
-					c = Curve.subdivide(c, a)[1];
-				}
-				var dx = c[6] - c[0],
-					dy = c[7] - c[1];
-				return Math.sqrt(dx * dx + dy * dy);
-			}
-			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
-					getIterations(a, b));
-		},
-
-		getTimeAt: function(v, offset, start) {
-			if (start === undefined)
-				start = offset < 0 ? 1 : 0;
-			if (offset === 0)
-				return start;
-			var abs = Math.abs,
-				epsilon = 1e-12,
-				forward = offset > 0,
-				a = forward ? start : 0,
-				b = forward ? 1 : start,
-				ds = getLengthIntegrand(v),
-				rangeLength = Curve.getLength(v, a, b, ds),
-				diff = abs(offset) - rangeLength;
-			if (abs(diff) < epsilon) {
-				return forward ? b : a;
-			} else if (diff > epsilon) {
-				return null;
-			}
-			var guess = offset / rangeLength,
-				length = 0;
-			function f(t) {
-				length += Numerical.integrate(ds, start, t,
-						getIterations(start, t));
-				start = t;
-				return length - offset;
-			}
-			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
-					1e-12);
-		},
-
-		getPoint: function(v, t) {
-			return evaluate(v, t, 0, false);
-		},
-
-		getTangent: function(v, t) {
-			return evaluate(v, t, 1, true);
-		},
-
-		getWeightedTangent: function(v, t) {
-			return evaluate(v, t, 1, false);
-		},
-
-		getNormal: function(v, t) {
-			return evaluate(v, t, 2, true);
-		},
-
-		getWeightedNormal: function(v, t) {
-			return evaluate(v, t, 2, false);
-		},
-
-		getCurvature: function(v, t) {
-			return evaluate(v, t, 3, false).x;
-		},
-
-		getPeaks: function(v) {
-			var x0 = v[0], y0 = v[1],
-				x1 = v[2], y1 = v[3],
-				x2 = v[4], y2 = v[5],
-				x3 = v[6], y3 = v[7],
-				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
-				bx =  3 * x0 - 6 * x1 + 3 * x2,
-				cx = -3 * x0 + 3 * x1,
-				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
-				by =  3 * y0 - 6 * y1 + 3 * y2,
-				cy = -3 * y0 + 3 * y1,
-				tMin = 1e-8,
-				tMax = 1 - tMin,
-				roots = [];
-			Numerical.solveCubic(
-					9 * (ax * ax + ay * ay),
-					9 * (ax * bx + by * ay),
-					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
-					(cx * bx + by * cy),
-					roots, tMin, tMax);
-			return roots.sort();
-		}
-	}};
-},
-new function() {
-
-	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
-		var excludeStart = !overlap && c1.getPrevious() === c2,
-			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
-			t1 <= (excludeEnd ? tMax : 1)) {
-			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
-				t2 <= (excludeStart ? tMax : 1)) {
-				var loc1 = new CurveLocation(c1, t1, null, overlap),
-					loc2 = new CurveLocation(c2, t2, null, overlap);
-				loc1._intersection = loc2;
-				loc2._intersection = loc1;
-				if (!include || include(loc1)) {
-					CurveLocation.insert(locations, loc1, true);
-				}
-			}
-		}
-	}
-
-	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
-			recursion, calls, tMin, tMax, uMin, uMax) {
-		if (++calls >= 4096 || ++recursion >= 40)
-			return calls;
-		var fatLineEpsilon = 1e-9,
-			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
-			getSignedDistance = Line.getSignedDistance,
-			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
-			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
-			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
-			dMin = factor * Math.min(0, d1, d2),
-			dMax = factor * Math.max(0, d1, d2),
-			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
-			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
-			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
-			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
-			hull = getConvexHull(dp0, dp1, dp2, dp3),
-			top = hull[0],
-			bottom = hull[1],
-			tMinClip,
-			tMaxClip;
-		if (d1 === 0 && d2 === 0
-				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
-			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
-			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
-				dMin, dMax)) == null)
-			return calls;
-		var tMinNew = tMin + (tMax - tMin) * tMinClip,
-			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
-		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
-			var t = (tMinNew + tMaxNew) / 2,
-				u = (uMin + uMax) / 2;
-			addLocation(locations, include,
-					flip ? c2 : c1, flip ? u : t,
-					flip ? c1 : c2, flip ? t : u);
-		} else {
-			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
-			var uDiff = uMax - uMin;
-			if (tMaxClip - tMinClip > 0.8) {
-				if (tMaxNew - tMinNew > uDiff) {
-					var parts = Curve.subdivide(v1, 0.5),
-						t = (tMinNew + tMaxNew) / 2;
-					calls = addCurveIntersections(
-							v2, parts[0], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, t);
-					calls = addCurveIntersections(
-							v2, parts[1], c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, t, tMaxNew);
-				} else {
-					var parts = Curve.subdivide(v2, 0.5),
-						u = (uMin + uMax) / 2;
-					calls = addCurveIntersections(
-							parts[0], v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, u, tMinNew, tMaxNew);
-					calls = addCurveIntersections(
-							parts[1], v1, c2, c1, locations, include, !flip,
-							recursion, calls, u, uMax, tMinNew, tMaxNew);
-				}
-			} else {
-				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
-					calls = addCurveIntersections(
-							v2, v1, c2, c1, locations, include, !flip,
-							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
-				} else {
-					calls = addCurveIntersections(
-							v1, v2, c1, c2, locations, include, flip,
-							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
-				}
-			}
-		}
-		return calls;
-	}
-
-	function getConvexHull(dq0, dq1, dq2, dq3) {
-		var p0 = [ 0, dq0 ],
-			p1 = [ 1 / 3, dq1 ],
-			p2 = [ 2 / 3, dq2 ],
-			p3 = [ 1, dq3 ],
-			dist1 = dq1 - (2 * dq0 + dq3) / 3,
-			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
-			hull;
-		if (dist1 * dist2 < 0) {
-			hull = [[p0, p1, p3], [p0, p2, p3]];
-		} else {
-			var distRatio = dist1 / dist2;
-			hull = [
-				distRatio >= 2 ? [p0, p1, p3]
-				: distRatio <= 0.5 ? [p0, p2, p3]
-				: [p0, p1, p2, p3],
-				[p0, p3]
-			];
-		}
-		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
-	}
-
-	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
-		if (hullTop[0][1] < dMin) {
-			return clipConvexHullPart(hullTop, true, dMin);
-		} else if (hullBottom[0][1] > dMax) {
-			return clipConvexHullPart(hullBottom, false, dMax);
-		} else {
-			return hullTop[0][0];
-		}
-	}
-
-	function clipConvexHullPart(part, top, threshold) {
-		var px = part[0][0],
-			py = part[0][1];
-		for (var i = 1, l = part.length; i < l; i++) {
-			var qx = part[i][0],
-				qy = part[i][1];
-			if (top ? qy >= threshold : qy <= threshold) {
-				return qy === threshold ? qx
-						: px + (threshold - py) * (qx - px) / (qy - py);
-			}
-			px = qx;
-			py = qy;
-		}
-		return null;
-	}
-
-	function getCurveLineIntersections(v, px, py, vx, vy) {
-		var isZero = Numerical.isZero;
-		if (isZero(vx) && isZero(vy)) {
-			var t = Curve.getTimeOf(v, new Point(px, py));
-			return t === null ? [] : [t];
-		}
-		var angle = Math.atan2(-vy, vx),
-			sin = Math.sin(angle),
-			cos = Math.cos(angle),
-			rv = [],
-			roots = [];
-		for (var i = 0; i < 8; i += 2) {
-			var x = v[i] - px,
-				y = v[i + 1] - py;
-			rv.push(
-				x * cos - y * sin,
-				x * sin + y * cos);
-		}
-		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
-		return roots;
-	}
-
-	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
-			flip) {
-		var x1 = v2[0], y1 = v2[1],
-			x2 = v2[6], y2 = v2[7],
-			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
-		for (var i = 0, l = roots.length; i < l; i++) {
-			var t1 = roots[i],
-				p1 = Curve.getPoint(v1, t1),
-				t2 = Curve.getTimeOf(v2, p1);
-			if (t2 !== null) {
-				addLocation(locations, include,
-						flip ? c2 : c1, flip ? t2 : t1,
-						flip ? c1 : c2, flip ? t1 : t2);
-			}
-		}
-	}
-
-	function addLineIntersection(v1, v2, c1, c2, locations, include) {
-		var pt = Line.intersect(
-				v1[0], v1[1], v1[6], v1[7],
-				v2[0], v2[1], v2[6], v2[7]);
-		if (pt) {
-			addLocation(locations, include,
-					c1, Curve.getTimeOf(v1, pt),
-					c2, Curve.getTimeOf(v2, pt));
-		}
-	}
-
-	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
-		var epsilon = 1e-12,
-			min = Math.min,
-			max = Math.max;
-
-		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
-			min(v2[0], v2[2], v2[4], v2[6]) &&
-			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
-			max(v2[0], v2[2], v2[4], v2[6]) &&
-			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
-			min(v2[1], v2[3], v2[5], v2[7]) &&
-			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
-			max(v2[1], v2[3], v2[5], v2[7])) {
-			var overlaps = getOverlaps(v1, v2);
-			if (overlaps) {
-				for (var i = 0; i < 2; i++) {
-					var overlap = overlaps[i];
-					addLocation(locations, include,
-							c1, overlap[0],
-							c2, overlap[1], true);
-				}
-			} else {
-				var straight1 = Curve.isStraight(v1),
-					straight2 = Curve.isStraight(v2),
-					straight = straight1 && straight2,
-					flip = straight1 && !straight2,
-					before = locations.length;
-				(straight
-					? addLineIntersection
-					: straight1 || straight2
-						? addCurveLineIntersections
-						: addCurveIntersections)(
-							flip ? v2 : v1, flip ? v1 : v2,
-							flip ? c2 : c1, flip ? c1 : c2,
-							locations, include, flip,
-							0, 0, 0, 1, 0, 1);
-				if (!straight || locations.length === before) {
-					for (var i = 0; i < 4; i++) {
-						var t1 = i >> 1,
-							t2 = i & 1,
-							i1 = t1 * 6,
-							i2 = t2 * 6,
-							p1 = new Point(v1[i1], v1[i1 + 1]),
-							p2 = new Point(v2[i2], v2[i2 + 1]);
-						if (p1.isClose(p2, epsilon)) {
-							addLocation(locations, include,
-									c1, t1,
-									c2, t2);
-						}
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getSelfIntersection(v1, c1, locations, include) {
-		var info = Curve.classify(v1);
-		if (info.type === 'loop') {
-			var roots = info.roots;
-			addLocation(locations, include,
-					c1, roots[0],
-					c1, roots[1]);
-		}
-	  return locations;
-	}
-
-	function getIntersections(curves1, curves2, include, matrix1, matrix2,
-			_returnFirst) {
-		var epsilon = 1e-7,
-			self = !curves2;
-		if (self)
-			curves2 = curves1;
-		var length1 = curves1.length,
-			length2 = curves2.length,
-			values1 = new Array(length1),
-			values2 = self ? values1 : new Array(length2),
-			locations = [];
-
-		for (var i = 0; i < length1; i++) {
-			values1[i] = curves1[i].getValues(matrix1);
-		}
-		if (!self) {
-			for (var i = 0; i < length2; i++) {
-				values2[i] = curves2[i].getValues(matrix2);
-			}
-		}
-		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
-				values1, values2, epsilon);
-		for (var index1 = 0; index1 < length1; index1++) {
-			var curve1 = curves1[index1],
-				v1 = values1[index1];
-			if (self) {
-				getSelfIntersection(v1, curve1, locations, include);
-			}
-			var collisions1 = boundsCollisions[index1];
-			if (collisions1) {
-				for (var j = 0; j < collisions1.length; j++) {
-					if (_returnFirst && locations.length)
-						return locations;
-					var index2 = collisions1[j];
-					if (!self || index2 > index1) {
-						var curve2 = curves2[index2],
-							v2 = values2[index2];
-						getCurveIntersections(
-								v1, v2, curve1, curve2, locations, include);
-					}
-				}
-			}
-		}
-		return locations;
-	}
-
-	function getOverlaps(v1, v2) {
-
-		function getSquaredLineLength(v) {
-			var x = v[6] - v[0],
-				y = v[7] - v[1];
-			return x * x + y * y;
-		}
-
-		var abs = Math.abs,
-			getDistance = Line.getDistance,
-			timeEpsilon = 1e-8,
-			geomEpsilon = 1e-7,
-			straight1 = Curve.isStraight(v1),
-			straight2 = Curve.isStraight(v2),
-			straightBoth = straight1 && straight2,
-			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
-			l1 = flip ? v2 : v1,
-			l2 = flip ? v1 : v2,
-			px = l1[0], py = l1[1],
-			vx = l1[6] - px, vy = l1[7] - py;
-		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
-			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
-			if (!straightBoth &&
-				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
-				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
-				straight1 = straight2 = straightBoth = true;
-			}
-		} else if (straightBoth) {
-			return null;
-		}
-		if (straight1 ^ straight2) {
-			return null;
-		}
-
-		var v = [v1, v2],
-			pairs = [];
-		for (var i = 0; i < 4 && pairs.length < 2; i++) {
-			var i1 = i & 1,
-				i2 = i1 ^ 1,
-				t1 = i >> 1,
-				t2 = Curve.getTimeOf(v[i1], new Point(
-					v[i2][t1 ? 6 : 0],
-					v[i2][t1 ? 7 : 1]));
-			if (t2 != null) {
-				var pair = i1 ? [t1, t2] : [t2, t1];
-				if (!pairs.length ||
-					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
-					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
-					pairs.push(pair);
-				}
-			}
-			if (i > 2 && !pairs.length)
-				break;
-		}
-		if (pairs.length !== 2) {
-			pairs = null;
-		} else if (!straightBoth) {
-			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
-				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
-			if (abs(o2[2] - o1[2]) > geomEpsilon ||
-				abs(o2[3] - o1[3]) > geomEpsilon ||
-				abs(o2[4] - o1[4]) > geomEpsilon ||
-				abs(o2[5] - o1[5]) > geomEpsilon)
-				pairs = null;
-		}
-		return pairs;
-	}
-
-	function getTimesWithTangent(v, tangent) {
-		var x0 = v[0], y0 = v[1],
-			x1 = v[2], y1 = v[3],
-			x2 = v[4], y2 = v[5],
-			x3 = v[6], y3 = v[7],
-			normalized = tangent.normalize(),
-			tx = normalized.x,
-			ty = normalized.y,
-			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
-			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
-			bx = 6 * x2 - 12 * x1 + 6 * x0,
-			by = 6 * y2 - 12 * y1 + 6 * y0,
-			cx = 3 * x1 - 3 * x0,
-			cy = 3 * y1 - 3 * y0,
-			den = 2 * ax * ty - 2 * ay * tx,
-			times = [];
-		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
-			var num = ax * cy - ay * cx,
-				den = ax * by - ay * bx;
-			if (den != 0) {
-				var t = -num / den;
-				if (t >= 0 && t <= 1) times.push(t);
-			}
-		} else {
-			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
-				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
-				(by * by - 4 * ay * cy) * tx * tx,
-				k = bx * ty - by * tx;
-			if (delta >= 0 && den != 0) {
-				var d = Math.sqrt(delta),
-					t0 = -(k + d) / den,
-					t1 = (-k + d) / den;
-				if (t0 >= 0 && t0 <= 1) times.push(t0);
-				if (t1 >= 0 && t1 <= 1) times.push(t1);
-			}
-		}
-		return times;
-	}
-
-	return {
-		getIntersections: function(curve) {
-			var v1 = this.getValues(),
-				v2 = curve && curve !== this && curve.getValues();
-			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
-					  : getSelfIntersection(v1, this, []);
-		},
-
-		statics: {
-			getOverlaps: getOverlaps,
-			getIntersections: getIntersections,
-			getCurveLineIntersections: getCurveLineIntersections,
-			getTimesWithTangent: getTimesWithTangent
-		}
-	};
-});
-
-var CurveLocation = Base.extend({
-	_class: 'CurveLocation',
-
-	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
-		if (time >= 0.99999999) {
-			var next = curve.getNext();
-			if (next) {
-				time = 0;
-				curve = next;
-			}
-		}
-		this._setCurve(curve);
-		this._time = time;
-		this._point = point || curve.getPointAtTime(time);
-		this._overlap = _overlap;
-		this._distance = _distance;
-		this._intersection = this._next = this._previous = null;
-	},
-
-	_setPath: function(path) {
-		this._path = path;
-		this._version = path ? path._version : 0;
-	},
-
-	_setCurve: function(curve) {
-		this._setPath(curve._path);
-		this._curve = curve;
-		this._segment = null;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
-	},
-
-	_setSegment: function(segment) {
-		var curve = segment.getCurve();
-		if (curve) {
-			this._setCurve(curve);
-		} else {
-			this._setPath(segment._path);
-			this._segment1 = segment;
-			this._segment2 = null;
-		}
-		this._segment = segment;
-		this._time = segment === this._segment1 ? 0 : 1;
-		this._point = segment._point.clone();
-	},
-
-	getSegment: function() {
-		var segment = this._segment;
-		if (!segment) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			if (time === 0) {
-				segment = curve._segment1;
-			} else if (time === 1) {
-				segment = curve._segment2;
-			} else if (time != null) {
-				segment = curve.getPartLength(0, time)
-					< curve.getPartLength(time, 1)
-						? curve._segment1
-						: curve._segment2;
-			}
-			this._segment = segment;
-		}
-		return segment;
-	},
-
-	getCurve: function() {
-		var path = this._path,
-			that = this;
-		if (path && path._version !== this._version) {
-			this._time = this._offset = this._curveOffset = this._curve = null;
-		}
-
-		function trySegment(segment) {
-			var curve = segment && segment.getCurve();
-			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
-				that._setCurve(curve);
-				return curve;
-			}
-		}
-
-		return this._curve
-			|| trySegment(this._segment)
-			|| trySegment(this._segment1)
-			|| trySegment(this._segment2.getPrevious());
-	},
-
-	getPath: function() {
-		var curve = this.getCurve();
-		return curve && curve._path;
-	},
-
-	getIndex: function() {
-		var curve = this.getCurve();
-		return curve && curve.getIndex();
-	},
-
-	getTime: function() {
-		var curve = this.getCurve(),
-			time = this._time;
-		return curve && time == null
-			? this._time = curve.getTimeOf(this._point)
-			: time;
-	},
-
-	getParameter: '#getTime',
-
-	getPoint: function() {
-		return this._point;
-	},
-
-	getOffset: function() {
-		var offset = this._offset;
-		if (offset == null) {
-			offset = 0;
-			var path = this.getPath(),
-				index = this.getIndex();
-			if (path && index != null) {
-				var curves = path.getCurves();
-				for (var i = 0; i < index; i++)
-					offset += curves[i].getLength();
-			}
-			this._offset = offset += this.getCurveOffset();
-		}
-		return offset;
-	},
-
-	getCurveOffset: function() {
-		var offset = this._curveOffset;
-		if (offset == null) {
-			var curve = this.getCurve(),
-				time = this.getTime();
-			this._curveOffset = offset = time != null && curve
-					&& curve.getPartLength(0, time);
-		}
-		return offset;
-	},
-
-	getIntersection: function() {
-		return this._intersection;
-	},
-
-	getDistance: function() {
-		return this._distance;
-	},
-
-	divide: function() {
-		var curve = this.getCurve(),
-			res = curve && curve.divideAtTime(this.getTime());
-		if (res) {
-			this._setSegment(res._segment1);
-		}
-		return res;
-	},
-
-	split: function() {
-		var curve = this.getCurve(),
-			path = curve._path,
-			res = curve && curve.splitAtTime(this.getTime());
-		if (res) {
-			this._setSegment(path.getLastSegment());
-		}
-		return  res;
-	},
-
-	equals: function(loc, _ignoreOther) {
-		var res = this === loc;
-		if (!res && loc instanceof CurveLocation) {
-			var c1 = this.getCurve(),
-				c2 = loc.getCurve(),
-				p1 = c1._path,
-				p2 = c2._path;
-			if (p1 === p2) {
-				var abs = Math.abs,
-					epsilon = 1e-7,
-					diff = abs(this.getOffset() - loc.getOffset()),
-					i1 = !_ignoreOther && this._intersection,
-					i2 = !_ignoreOther && loc._intersection;
-				res = (diff < epsilon
-						|| p1 && abs(p1.getLength() - diff) < epsilon)
-					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
-			}
-		}
-		return res;
-	},
-
-	toString: function() {
-		var parts = [],
-			point = this.getPoint(),
-			f = Formatter.instance;
-		if (point)
-			parts.push('point: ' + point);
-		var index = this.getIndex();
-		if (index != null)
-			parts.push('index: ' + index);
-		var time = this.getTime();
-		if (time != null)
-			parts.push('time: ' + f.number(time));
-		if (this._distance != null)
-			parts.push('distance: ' + f.number(this._distance));
-		return '{ ' + parts.join(', ') + ' }';
-	},
-
-	isTouching: function() {
-		var inter = this._intersection;
-		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
-			var curve1 = this.getCurve(),
-				curve2 = inter.getCurve();
-			return !(curve1.isStraight() && curve2.isStraight()
-					&& curve1.getLine().intersect(curve2.getLine()));
-		}
-		return false;
-	},
-
-	isCrossing: function() {
-		var inter = this._intersection;
-		if (!inter)
-			return false;
-		var t1 = this.getTime(),
-			t2 = inter.getTime(),
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			t1Inside = t1 >= tMin && t1 <= tMax,
-			t2Inside = t2 >= tMin && t2 <= tMax;
-		if (t1Inside && t2Inside)
-			return !this.isTouching();
-		var c2 = this.getCurve(),
-			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
-			c4 = inter.getCurve(),
-			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
-		if (t1 > tMax)
-			c2 = c2.getNext();
-		if (t2 > tMax)
-			c4 = c4.getNext();
-		if (!c1 || !c2 || !c3 || !c4)
-			return false;
-
-		var offsets = [];
-
-		function addOffsets(curve, end) {
-			var v = curve.getValues(),
-				roots = Curve.classify(v).roots || Curve.getPeaks(v),
-				count = roots.length,
-				offset = Curve.getLength(v,
-					end && count ? roots[count - 1] : 0,
-					!end && count ? roots[0] : 1);
-			offsets.push(count ? offset : offset / 32);
-		}
-
-		function isInRange(angle, min, max) {
-			return min < max
-					? angle > min && angle < max
-					: angle > min || angle < max;
-		}
-
-		if (!t1Inside) {
-			addOffsets(c1, true);
-			addOffsets(c2, false);
-		}
-		if (!t2Inside) {
-			addOffsets(c3, true);
-			addOffsets(c4, false);
-		}
-		var pt = this.getPoint(),
-			offset = Math.min.apply(Math, offsets),
-			v2 = t1Inside ? c2.getTangentAtTime(t1)
-					: c2.getPointAt(offset).subtract(pt),
-			v1 = t1Inside ? v2.negate()
-					: c1.getPointAt(-offset).subtract(pt),
-			v4 = t2Inside ? c4.getTangentAtTime(t2)
-					: c4.getPointAt(offset).subtract(pt),
-			v3 = t2Inside ? v4.negate()
-					: c3.getPointAt(-offset).subtract(pt),
-			a1 = v1.getAngle(),
-			a2 = v2.getAngle(),
-			a3 = v3.getAngle(),
-			a4 = v4.getAngle();
-		return !!(t1Inside
-				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
-				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
-				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
-				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
-	},
-
-	hasOverlap: function() {
-		return !!this._overlap;
-	}
-}, Base.each(Curve._evaluateMethods, function(name) {
-	var get = name + 'At';
-	this[name] = function() {
-		var curve = this.getCurve(),
-			time = this.getTime();
-		return time != null && curve && curve[get](time, true);
-	};
-}, {
-	preserve: true
-}),
-new function() {
-
-	function insert(locations, loc, merge) {
-		var length = locations.length,
-			l = 0,
-			r = length - 1;
-
-		function search(index, dir) {
-			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
-				var loc2 = locations[((i % length) + length) % length];
-				if (!loc.getPoint().isClose(loc2.getPoint(),
-						1e-7))
-					break;
-				if (loc.equals(loc2))
-					return loc2;
-			}
-			return null;
-		}
-
-		while (l <= r) {
-			var m = (l + r) >>> 1,
-				loc2 = locations[m],
-				found;
-			if (merge && (found = loc.equals(loc2) ? loc2
-					: (search(m, -1) || search(m, 1)))) {
-				if (loc._overlap) {
-					found._overlap = found._intersection._overlap = true;
-				}
-				return found;
-			}
-		var path1 = loc.getPath(),
-			path2 = loc2.getPath(),
-			diff = path1 !== path2
-				? path1._id - path2._id
-				: (loc.getIndex() + loc.getTime())
-				- (loc2.getIndex() + loc2.getTime());
-			if (diff < 0) {
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		locations.splice(l, 0, loc);
-		return loc;
-	}
-
-	return { statics: {
-		insert: insert,
-
-		expand: function(locations) {
-			var expanded = locations.slice();
-			for (var i = locations.length - 1; i >= 0; i--) {
-				insert(expanded, locations[i]._intersection, false);
-			}
-			return expanded;
-		}
-	}};
-});
-
-var PathItem = Item.extend({
-	_class: 'PathItem',
-	_selectBounds: false,
-	_canScaleStroke: true,
-	beans: true,
-
-	initialize: function PathItem() {
-	},
-
-	statics: {
-		create: function(arg) {
-			var data,
-				segments,
-				compound;
-			if (Base.isPlainObject(arg)) {
-				segments = arg.segments;
-				data = arg.pathData;
-			} else if (Array.isArray(arg)) {
-				segments = arg;
-			} else if (typeof arg === 'string') {
-				data = arg;
-			}
-			if (segments) {
-				var first = segments[0];
-				compound = first && Array.isArray(first[0]);
-			} else if (data) {
-				compound = (data.match(/m/gi) || []).length > 1
-						|| /z\s*\S+/i.test(data);
-			}
-			var ctor = compound ? CompoundPath : Path;
-			return new ctor(arg);
-		}
-	},
-
-	_asPathItem: function() {
-		return this;
-	},
-
-	isClockwise: function() {
-		return this.getArea() >= 0;
-	},
-
-	setClockwise: function(clockwise) {
-		if (this.isClockwise() != (clockwise = !!clockwise))
-			this.reverse();
-	},
-
-	setPathData: function(data) {
-
-		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
-			coords,
-			relative = false,
-			previous,
-			control,
-			current = new Point(),
-			start = new Point();
-
-		function getCoord(index, coord) {
-			var val = +coords[index];
-			if (relative)
-				val += current[coord];
-			return val;
-		}
-
-		function getPoint(index) {
-			return new Point(
-				getCoord(index, 'x'),
-				getCoord(index + 1, 'y')
-			);
-		}
-
-		this.clear();
-
-		for (var i = 0, l = parts && parts.length; i < l; i++) {
-			var part = parts[i],
-				command = part[0],
-				lower = command.toLowerCase();
-			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
-			var length = coords && coords.length;
-			relative = command === lower;
-			if (previous === 'z' && !/[mz]/.test(lower))
-				this.moveTo(current);
-			switch (lower) {
-			case 'm':
-			case 'l':
-				var move = lower === 'm';
-				for (var j = 0; j < length; j += 2) {
-					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
-					if (move) {
-						start = current;
-						move = false;
-					}
-				}
-				control = current;
-				break;
-			case 'h':
-			case 'v':
-				var coord = lower === 'h' ? 'x' : 'y';
-				current = current.clone();
-				for (var j = 0; j < length; j++) {
-					current[coord] = getCoord(j, coord);
-					this.lineTo(current);
-				}
-				control = current;
-				break;
-			case 'c':
-				for (var j = 0; j < length; j += 6) {
-					this.cubicCurveTo(
-							getPoint(j),
-							control = getPoint(j + 2),
-							current = getPoint(j + 4));
-				}
-				break;
-			case 's':
-				for (var j = 0; j < length; j += 4) {
-					this.cubicCurveTo(
-							/[cs]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current,
-							control = getPoint(j),
-							current = getPoint(j + 2));
-					previous = lower;
-				}
-				break;
-			case 'q':
-				for (var j = 0; j < length; j += 4) {
-					this.quadraticCurveTo(
-							control = getPoint(j),
-							current = getPoint(j + 2));
-				}
-				break;
-			case 't':
-				for (var j = 0; j < length; j += 2) {
-					this.quadraticCurveTo(
-							control = (/[qt]/.test(previous)
-									? current.multiply(2).subtract(control)
-									: current),
-							current = getPoint(j));
-					previous = lower;
-				}
-				break;
-			case 'a':
-				for (var j = 0; j < length; j += 7) {
-					this.arcTo(current = getPoint(j + 5),
-							new Size(+coords[j], +coords[j + 1]),
-							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
-				}
-				break;
-			case 'z':
-				this.closePath(1e-12);
-				current = start;
-				break;
-			}
-			previous = lower;
-		}
-	},
-
-	_canComposite: function() {
-		return !(this.hasFill() && this.hasStroke());
-	},
-
-	_contains: function(point) {
-		var winding = point.isInside(
-				this.getBounds({ internal: true, handle: true }))
-					? this._getWinding(point)
-					: {};
-		return winding.onPath || !!(this.getFillRule() === 'evenodd'
-				? winding.windingL & 1 || winding.windingR & 1
-				: winding.winding);
-	},
-
-	getIntersections: function(path, include, _matrix, _returnFirst) {
-		var self = this === path || !path,
-			matrix1 = this._matrix._orNullIfIdentity(),
-			matrix2 = self ? matrix1
-				: (_matrix || path._matrix)._orNullIfIdentity();
-		return self || this.getBounds(matrix1).intersects(
-				path.getBounds(matrix2), 1e-12)
-				? Curve.getIntersections(
-						this.getCurves(), !self && path.getCurves(), include,
-						matrix1, matrix2, _returnFirst)
-				: [];
-	},
-
-	getCrossings: function(path) {
-		return this.getIntersections(path, function(inter) {
-			return inter.isCrossing();
-		});
-	},
-
-	getNearestLocation: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves(),
-			minDist = Infinity,
-			minLoc = null;
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getNearestLocation(point);
-			if (loc._distance < minDist) {
-				minDist = loc._distance;
-				minLoc = loc;
-			}
-		}
-		return minLoc;
-	},
-
-	getNearestPoint: function() {
-		var loc = this.getNearestLocation.apply(this, arguments);
-		return loc ? loc.getPoint() : loc;
-	},
-
-	interpolate: function(from, to, factor) {
-		var isPath = !this._children,
-			name = isPath ? '_segments' : '_children',
-			itemsFrom = from[name],
-			itemsTo = to[name],
-			items = this[name];
-		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
-			throw new Error('Invalid operands in interpolate() call: ' +
-					from + ', ' + to);
-		}
-		var current = items.length,
-			length = itemsTo.length;
-		if (current < length) {
-			var ctor = isPath ? Segment : Path;
-			for (var i = current; i < length; i++) {
-				this.add(new ctor());
-			}
-		} else if (current > length) {
-			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
-		}
-		for (var i = 0; i < length; i++) {
-			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
-		}
-		if (isPath) {
-			this.setClosed(from._closed);
-			this._changed(9);
-		}
-	},
-
-	compare: function(path) {
-		var ok = false;
-		if (path) {
-			var paths1 = this._children || [this],
-				paths2 = path._children ? path._children.slice() : [path],
-				length1 = paths1.length,
-				length2 = paths2.length,
-				matched = [],
-				count = 0;
-			ok = true;
-			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
-			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
-				var path1 = paths1[i1];
-				ok = false;
-				var pathBoundsOverlaps = boundsOverlaps[i1];
-				if (pathBoundsOverlaps) {
-					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
-						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
-							if (!matched[pathBoundsOverlaps[i2]]) {
-								matched[pathBoundsOverlaps[i2]] = true;
-								count++;
-							}
-							ok = true;
-						}
-					}
-				}
-			}
-			ok = ok && count === length2;
-		}
-		return ok;
-	},
-
-});
-
-var Path = PathItem.extend({
-	_class: 'Path',
-	_serializeFields: {
-		segments: [],
-		closed: false
-	},
-
-	initialize: function Path(arg) {
-		this._closed = false;
-		this._segments = [];
-		this._version = 0;
-		var args = arguments,
-			segments = Array.isArray(arg)
-			? typeof arg[0] === 'object'
-				? arg
-				: args
-			: arg && (arg.size === undefined && (arg.x !== undefined
-					|| arg.point !== undefined))
-				? args
-				: null;
-		if (segments && segments.length > 0) {
-			this.setSegments(segments);
-		} else {
-			this._curves = undefined;
-			this._segmentSelection = 0;
-			if (!segments && typeof arg === 'string') {
-				this.setPathData(arg);
-				arg = null;
-			}
-		}
-		this._initialize(!segments && arg);
-	},
-
-	_equals: function(item) {
-		return this._closed === item._closed
-				&& Base.equals(this._segments, item._segments);
-	},
-
-	copyContent: function(source) {
-		this.setSegments(source._segments);
-		this._closed = source._closed;
-	},
-
-	_changed: function _changed(flags) {
-		_changed.base.call(this, flags);
-		if (flags & 8) {
-			this._length = this._area = undefined;
-			if (flags & 32) {
-				this._version++;
-			} else if (this._curves) {
-			   for (var i = 0, l = this._curves.length; i < l; i++)
-					this._curves[i]._changed();
-			}
-		} else if (flags & 64) {
-			this._bounds = undefined;
-		}
-	},
-
-	getStyle: function() {
-		var parent = this._parent;
-		return (parent instanceof CompoundPath ? parent : this)._style;
-	},
-
-	getSegments: function() {
-		return this._segments;
-	},
-
-	setSegments: function(segments) {
-		var fullySelected = this.isFullySelected(),
-			length = segments && segments.length;
-		this._segments.length = 0;
-		this._segmentSelection = 0;
-		this._curves = undefined;
-		if (length) {
-			var last = segments[length - 1];
-			if (typeof last === 'boolean') {
-				this.setClosed(last);
-				length--;
-			}
-			this._add(Segment.readList(segments, 0, {}, length));
-		}
-		if (fullySelected)
-			this.setFullySelected(true);
-	},
-
-	getFirstSegment: function() {
-		return this._segments[0];
-	},
-
-	getLastSegment: function() {
-		return this._segments[this._segments.length - 1];
-	},
-
-	getCurves: function() {
-		var curves = this._curves,
-			segments = this._segments;
-		if (!curves) {
-			var length = this._countCurves();
-			curves = this._curves = new Array(length);
-			for (var i = 0; i < length; i++)
-				curves[i] = new Curve(this, segments[i],
-					segments[i + 1] || segments[0]);
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		return this.getCurves()[0];
-	},
-
-	getLastCurve: function() {
-		var curves = this.getCurves();
-		return curves[curves.length - 1];
-	},
-
-	isClosed: function() {
-		return this._closed;
-	},
-
-	setClosed: function(closed) {
-		if (this._closed != (closed = !!closed)) {
-			this._closed = closed;
-			if (this._curves) {
-				var length = this._curves.length = this._countCurves();
-				if (closed)
-					this._curves[length - 1] = new Curve(this,
-						this._segments[length - 1], this._segments[0]);
-			}
-			this._changed(41);
-		}
-	}
-}, {
-	beans: true,
-
-	getPathData: function(_matrix, _precision) {
-		var segments = this._segments,
-			length = segments.length,
-			f = new Formatter(_precision),
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY,
-			parts = [];
-
-		function addSegment(segment, skipLine) {
-			segment._transformCoordinates(_matrix, coords);
-			curX = coords[0];
-			curY = coords[1];
-			if (first) {
-				parts.push('M' + f.pair(curX, curY));
-				first = false;
-			} else {
-				inX = coords[2];
-				inY = coords[3];
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					if (!skipLine) {
-						var dx = curX - prevX,
-							dy = curY - prevY;
-						parts.push(
-							  dx === 0 ? 'v' + f.number(dy)
-							: dy === 0 ? 'h' + f.number(dx)
-							: 'l' + f.pair(dx, dy));
-					}
-				} else {
-					parts.push('c' + f.pair(outX - prevX, outY - prevY)
-							 + ' ' + f.pair( inX - prevX,  inY - prevY)
-							 + ' ' + f.pair(curX - prevX, curY - prevY));
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			outX = coords[4];
-			outY = coords[5];
-		}
-
-		if (!length)
-			return '';
-
-		for (var i = 0; i < length; i++)
-			addSegment(segments[i]);
-		if (this._closed && length > 0) {
-			addSegment(segments[0], true);
-			parts.push('z');
-		}
-		return parts.join('');
-	},
-
-	isEmpty: function() {
-		return !this._segments.length;
-	},
-
-	_transformContent: function(matrix) {
-		var segments = this._segments,
-			coords = new Array(6);
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i]._transformCoordinates(matrix, coords, true);
-		return true;
-	},
-
-	_add: function(segs, index) {
-		var segments = this._segments,
-			curves = this._curves,
-			amount = segs.length,
-			append = index == null,
-			index = append ? segments.length : index;
-		for (var i = 0; i < amount; i++) {
-			var segment = segs[i];
-			if (segment._path)
-				segment = segs[i] = segment.clone();
-			segment._path = this;
-			segment._index = index + i;
-			if (segment._selection)
-				this._updateSelection(segment, 0, segment._selection);
-		}
-		if (append) {
-			Base.push(segments, segs);
-		} else {
-			segments.splice.apply(segments, [index, 0].concat(segs));
-			for (var i = index + amount, l = segments.length; i < l; i++)
-				segments[i]._index = i;
-		}
-		if (curves) {
-			var total = this._countCurves(),
-				start = index > 0 && index + amount - 1 === total ? index - 1
-					: index,
-				insert = start,
-				end = Math.min(start + amount, total);
-			if (segs._curves) {
-				curves.splice.apply(curves, [start, 0].concat(segs._curves));
-				insert += segs._curves.length;
-			}
-			for (var i = insert; i < end; i++)
-				curves.splice(i, 0, new Curve(this, null, null));
-			this._adjustCurves(start, end);
-		}
-		this._changed(41);
-		return segs;
-	},
-
-	_adjustCurves: function(start, end) {
-		var segments = this._segments,
-			curves = this._curves,
-			curve;
-		for (var i = start; i < end; i++) {
-			curve = curves[i];
-			curve._path = this;
-			curve._segment1 = segments[i];
-			curve._segment2 = segments[i + 1] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[this._closed && !start ? segments.length - 1
-				: start - 1]) {
-			curve._segment2 = segments[start] || segments[0];
-			curve._changed();
-		}
-		if (curve = curves[end]) {
-			curve._segment1 = segments[end];
-			curve._changed();
-		}
-	},
-
-	_countCurves: function() {
-		var length = this._segments.length;
-		return !this._closed && length > 0 ? length - 1 : length;
-	},
-
-	add: function(segment1 ) {
-		var args = arguments;
-		return args.length > 1 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args))
-			: this._add([ Segment.read(args) ])[0];
-	},
-
-	insert: function(index, segment1 ) {
-		var args = arguments;
-		return args.length > 2 && typeof segment1 !== 'number'
-			? this._add(Segment.readList(args, 1), index)
-			: this._add([ Segment.read(args, 1) ], index)[0];
-	},
-
-	addSegment: function() {
-		return this._add([ Segment.read(arguments) ])[0];
-	},
-
-	insertSegment: function(index ) {
-		return this._add([ Segment.read(arguments, 1) ], index)[0];
-	},
-
-	addSegments: function(segments) {
-		return this._add(Segment.readList(segments));
-	},
-
-	insertSegments: function(index, segments) {
-		return this._add(Segment.readList(segments), index);
-	},
-
-	removeSegment: function(index) {
-		return this.removeSegments(index, index + 1)[0] || null;
-	},
-
-	removeSegments: function(start, end, _includeCurves) {
-		start = start || 0;
-		end = Base.pick(end, this._segments.length);
-		var segments = this._segments,
-			curves = this._curves,
-			count = segments.length,
-			removed = segments.splice(start, end - start),
-			amount = removed.length;
-		if (!amount)
-			return removed;
-		for (var i = 0; i < amount; i++) {
-			var segment = removed[i];
-			if (segment._selection)
-				this._updateSelection(segment, segment._selection, 0);
-			segment._index = segment._path = null;
-		}
-		for (var i = start, l = segments.length; i < l; i++)
-			segments[i]._index = i;
-		if (curves) {
-			var index = start > 0 && end === count + (this._closed ? 1 : 0)
-					? start - 1
-					: start,
-				curves = curves.splice(index, amount);
-			for (var i = curves.length - 1; i >= 0; i--)
-				curves[i]._path = null;
-			if (_includeCurves)
-				removed._curves = curves.slice(1);
-			this._adjustCurves(index, index);
-		}
-		this._changed(41);
-		return removed;
-	},
-
-	clear: '#removeSegments',
-
-	hasHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			if (segments[i].hasHandles())
-				return true;
-		}
-		return false;
-	},
-
-	clearHandles: function() {
-		var segments = this._segments;
-		for (var i = 0, l = segments.length; i < l; i++)
-			segments[i].clearHandles();
-	},
-
-	getLength: function() {
-		if (this._length == null) {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++)
-				length += curves[i].getLength();
-			this._length = length;
-		}
-		return this._length;
-	},
-
-	getArea: function() {
-		var area = this._area;
-		if (area == null) {
-			var segments = this._segments,
-				closed = this._closed;
-			area = 0;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var last = i + 1 === l;
-				area += Curve.getArea(Curve.getValues(
-						segments[i], segments[last ? 0 : i + 1],
-						null, last && !closed));
-			}
-			this._area = area;
-		}
-		return area;
-	},
-
-	isFullySelected: function() {
-		var length = this._segments.length;
-		return this.isSelected() && length > 0 && this._segmentSelection
-				=== length * 7;
-	},
-
-	setFullySelected: function(selected) {
-		if (selected)
-			this._selectSegments(true);
-		this.setSelected(selected);
-	},
-
-	setSelection: function setSelection(selection) {
-		if (!(selection & 1))
-			this._selectSegments(false);
-		setSelection.base.call(this, selection);
-	},
-
-	_selectSegments: function(selected) {
-		var segments = this._segments,
-			length = segments.length,
-			selection = selected ? 7 : 0;
-		this._segmentSelection = selection * length;
-		for (var i = 0; i < length; i++)
-			segments[i]._selection = selection;
-	},
-
-	_updateSelection: function(segment, oldSelection, newSelection) {
-		segment._selection = newSelection;
-		var selection = this._segmentSelection += newSelection - oldSelection;
-		if (selection > 0)
-			this.setSelected(true);
-	},
-
-	divideAt: function(location) {
-		var loc = this.getLocationAt(location),
-			curve;
-		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
-				? curve._segment1
-				: null;
-	},
-
-	splitAt: function(location) {
-		var loc = this.getLocationAt(location),
-			index = loc && loc.index,
-			time = loc && loc.time,
-			tMin = 1e-8,
-			tMax = 1 - tMin;
-		if (time > tMax) {
-			index++;
-			time = 0;
-		}
-		var curves = this.getCurves();
-		if (index >= 0 && index < curves.length) {
-			if (time >= tMin) {
-				curves[index++].divideAtTime(time);
-			}
-			var segs = this.removeSegments(index, this._segments.length, true),
-				path;
-			if (this._closed) {
-				this.setClosed(false);
-				path = this;
-			} else {
-				path = new Path(Item.NO_INSERT);
-				path.insertAbove(this);
-				path.copyAttributes(this);
-			}
-			path._add(segs, 0);
-			this.addSegment(segs[0]);
-			return path;
-		}
-		return null;
-	},
-
-	split: function(index, time) {
-		var curve,
-			location = time === undefined ? index
-				: (curve = this.getCurves()[index])
-					&& curve.getLocationAtTime(time);
-		return location != null ? this.splitAt(location) : null;
-	},
-
-	join: function(path, tolerance) {
-		var epsilon = tolerance || 0;
-		if (path && path !== this) {
-			var segments = path._segments,
-				last1 = this.getLastSegment(),
-				last2 = path.getLastSegment();
-			if (!last2)
-				return this;
-			if (last1 && last1._point.isClose(last2._point, epsilon))
-				path.reverse();
-			var first2 = path.getFirstSegment();
-			if (last1 && last1._point.isClose(first2._point, epsilon)) {
-				last1.setHandleOut(first2._handleOut);
-				this._add(segments.slice(1));
-			} else {
-				var first1 = this.getFirstSegment();
-				if (first1 && first1._point.isClose(first2._point, epsilon))
-					path.reverse();
-				last2 = path.getLastSegment();
-				if (first1 && first1._point.isClose(last2._point, epsilon)) {
-					first1.setHandleIn(last2._handleIn);
-					this._add(segments.slice(0, segments.length - 1), 0);
-				} else {
-					this._add(segments.slice());
-				}
-			}
-			if (path._closed)
-				this._add([segments[0]]);
-			path.remove();
-		}
-		var first = this.getFirstSegment(),
-			last = this.getLastSegment();
-		if (first !== last && first._point.isClose(last._point, epsilon)) {
-			first.setHandleIn(last._handleIn);
-			last.remove();
-			this.setClosed(true);
-		}
-		return this;
-	},
-
-	reduce: function(options) {
-		var curves = this.getCurves(),
-			simplify = options && options.simplify,
-			tolerance = simplify ? 1e-7 : 0;
-		for (var i = curves.length - 1; i >= 0; i--) {
-			var curve = curves[i];
-			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
-					|| simplify && curve.isCollinear(curve.getNext())))
-				curve.remove();
-		}
-		return this;
-	},
-
-	reverse: function() {
-		this._segments.reverse();
-		for (var i = 0, l = this._segments.length; i < l; i++) {
-			var segment = this._segments[i];
-			var handleIn = segment._handleIn;
-			segment._handleIn = segment._handleOut;
-			segment._handleOut = handleIn;
-			segment._index = i;
-		}
-		this._curves = null;
-		this._changed(9);
-	},
-
-	flatten: function(flatness) {
-		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
-			parts = flattener.parts,
-			length = parts.length,
-			segments = [];
-		for (var i = 0; i < length; i++) {
-			segments.push(new Segment(parts[i].curve.slice(0, 2)));
-		}
-		if (!this._closed && length > 0) {
-			segments.push(new Segment(parts[length - 1].curve.slice(6)));
-		}
-		this.setSegments(segments);
-	},
-
-	simplify: function(tolerance) {
-		var segments = new PathFitter(this).fit(tolerance || 2.5);
-		if (segments)
-			this.setSegments(segments);
-		return !!segments;
-	},
-
-	smooth: function(options) {
-		var that = this,
-			opts = options || {},
-			type = opts.type || 'asymmetric',
-			segments = this._segments,
-			length = segments.length,
-			closed = this._closed;
-
-		function getIndex(value, _default) {
-			var index = value && value.index;
-			if (index != null) {
-				var path = value.path;
-				if (path && path !== that)
-					throw new Error(value._class + ' ' + index + ' of ' + path
-							+ ' is not part of ' + that);
-				if (_default && value instanceof Curve)
-					index++;
-			} else {
-				index = typeof value === 'number' ? value : _default;
-			}
-			return Math.min(index < 0 && closed
-					? index % length
-					: index < 0 ? index + length : index, length - 1);
-		}
-
-		var loop = closed && opts.from === undefined && opts.to === undefined,
-			from = getIndex(opts.from, 0),
-			to = getIndex(opts.to, length - 1);
-
-		if (from > to) {
-			if (closed) {
-				from -= length;
-			} else {
-				var tmp = from;
-				from = to;
-				to = tmp;
-			}
-		}
-		if (/^(?:asymmetric|continuous)$/.test(type)) {
-			var asymmetric = type === 'asymmetric',
-				min = Math.min,
-				amount = to - from + 1,
-				n = amount - 1,
-				padding = loop ? min(amount, 4) : 1,
-				paddingLeft = padding,
-				paddingRight = padding,
-				knots = [];
-			if (!closed) {
-				paddingLeft = min(1, from);
-				paddingRight = min(1, length - to - 1);
-			}
-			n += paddingLeft + paddingRight;
-			if (n <= 1)
-				return;
-			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
-				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
-			}
-
-			var x = knots[0]._x + 2 * knots[1]._x,
-				y = knots[0]._y + 2 * knots[1]._y,
-				f = 2,
-				n_1 = n - 1,
-				rx = [x],
-				ry = [y],
-				rf = [f],
-				px = [],
-				py = [];
-			for (var i = 1; i < n; i++) {
-				var internal = i < n_1,
-					a = internal ? 1 : asymmetric ? 1 : 2,
-					b = internal ? 4 : asymmetric ? 2 : 7,
-					u = internal ? 4 : asymmetric ? 3 : 8,
-					v = internal ? 2 : asymmetric ? 0 : 1,
-					m = a / f;
-				f = rf[i] = b - m;
-				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
-				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
-			}
-
-			px[n_1] = rx[n_1] / rf[n_1];
-			py[n_1] = ry[n_1] / rf[n_1];
-			for (var i = n - 2; i >= 0; i--) {
-				px[i] = (rx[i] - px[i + 1]) / rf[i];
-				py[i] = (ry[i] - py[i + 1]) / rf[i];
-			}
-			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
-			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
-
-			for (var i = paddingLeft, max = n - paddingRight, j = from;
-					i <= max; i++, j++) {
-				var segment = segments[j < 0 ? j + length : j],
-					pt = segment._point,
-					hx = px[i] - pt._x,
-					hy = py[i] - pt._y;
-				if (loop || i < max)
-					segment.setHandleOut(hx, hy);
-				if (loop || i > paddingLeft)
-					segment.setHandleIn(-hx, -hy);
-			}
-		} else {
-			for (var i = from; i <= to; i++) {
-				segments[i < 0 ? i + length : i].smooth(opts,
-						!loop && i === from, !loop && i === to);
-			}
-		}
-	},
-
-	toShape: function(insert) {
-		if (!this._closed)
-			return null;
-
-		var segments = this._segments,
-			type,
-			size,
-			radius,
-			topCenter;
-
-		function isCollinear(i, j) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				seg3 = segments[j],
-				seg4 = seg3.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isCollinear(
-						seg4._point.subtract(seg3._point));
-		}
-
-		function isOrthogonal(i) {
-			var seg2 = segments[i],
-				seg1 = seg2.getPrevious(),
-				seg3 = seg2.getNext();
-			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
-					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
-					&& seg2._point.subtract(seg1._point).isOrthogonal(
-						seg3._point.subtract(seg2._point));
-		}
-
-		function isArc(i) {
-			var seg1 = segments[i],
-				seg2 = seg1.getNext(),
-				handle1 = seg1._handleOut,
-				handle2 = seg2._handleIn,
-				kappa = 0.5522847498307936;
-			if (handle1.isOrthogonal(handle2)) {
-				var pt1 = seg1._point,
-					pt2 = seg2._point,
-					corner = new Line(pt1, handle1, true).intersect(
-							new Line(pt2, handle2, true), true);
-				return corner && Numerical.isZero(handle1.getLength() /
-						corner.subtract(pt1).getLength() - kappa)
-					&& Numerical.isZero(handle2.getLength() /
-						corner.subtract(pt2).getLength() - kappa);
-			}
-			return false;
-		}
-
-		function getDistance(i, j) {
-			return segments[i]._point.getDistance(segments[j]._point);
-		}
-
-		if (!this.hasHandles() && segments.length === 4
-				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(0, 3), getDistance(0, 1));
-			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
-		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
-				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
-			type = Shape.Rectangle;
-			size = new Size(getDistance(1, 6), getDistance(0, 3));
-			radius = size.subtract(new Size(getDistance(0, 7),
-					getDistance(1, 2))).divide(2);
-			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
-		} else if (segments.length === 4
-				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
-			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
-				type = Shape.Circle;
-				radius = getDistance(0, 2) / 2;
-			} else {
-				type = Shape.Ellipse;
-				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
-			}
-			topCenter = segments[1]._point;
-		}
-
-		if (type) {
-			var center = this.getPosition(true),
-				shape = new type({
-					center: center,
-					size: size,
-					radius: radius,
-					insert: false
-				});
-			shape.copyAttributes(this, true);
-			shape._matrix.prepend(this._matrix);
-			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			if (insert === undefined || insert)
-				shape.insertAbove(this);
-			return shape;
-		}
-		return null;
-	},
-
-	toPath: '#clone',
-
-	compare: function compare(path) {
-		if (!path || path instanceof CompoundPath)
-			return compare.base.call(this, path);
-		var curves1 = this.getCurves(),
-			curves2 = path.getCurves(),
-			length1 = curves1.length,
-			length2 = curves2.length;
-		if (!length1 || !length2) {
-			return length1 == length2;
-		}
-		var v1 = curves1[0].getValues(),
-			values2 = [],
-			pos1 = 0, pos2,
-			end1 = 0, end2;
-		for (var i = 0; i < length2; i++) {
-			var v2 = curves2[i].getValues();
-			values2.push(v2);
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
-				end2 = overlaps[0][1];
-				break;
-			}
-		}
-		var abs = Math.abs,
-			epsilon = 1e-8,
-			v2 = values2[pos2],
-			start2;
-		while (v1 && v2) {
-			var overlaps = Curve.getOverlaps(v1, v2);
-			if (overlaps) {
-				var t1 = overlaps[0][0];
-				if (abs(t1 - end1) < epsilon) {
-					end1 = overlaps[1][0];
-					if (end1 === 1) {
-						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
-						end1 = 0;
-					}
-					var t2 = overlaps[0][1];
-					if (abs(t2 - end2) < epsilon) {
-						if (!start2)
-							start2 = [pos2, t2];
-						end2 = overlaps[1][1];
-						if (end2 === 1) {
-							if (++pos2 >= length2)
-								pos2 = 0;
-							v2 = values2[pos2] || curves2[pos2].getValues();
-							end2 = 0;
-						}
-						if (!v1) {
-							return start2[0] === pos2 && start2[1] === end2;
-						}
-						continue;
-					}
-				}
-			}
-			break;
-		}
-		return false;
-	},
-
-	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
-		var that = this,
-			style = this.getStyle(),
-			segments = this._segments,
-			numSegments = segments.length,
-			closed = this._closed,
-			tolerancePadding = options._tolerancePadding,
-			strokePadding = tolerancePadding,
-			join, cap, miterLimit,
-			area, loc, res,
-			hitStroke = options.stroke && style.hasStroke(),
-			hitFill = options.fill && style.hasFill(),
-			hitCurves = options.curves,
-			strokeRadius = hitStroke
-					? style.getStrokeWidth() / 2
-					: hitFill && options.tolerance > 0 || hitCurves
-						? 0 : null;
-		if (strokeRadius !== null) {
-			if (strokeRadius > 0) {
-				join = style.getStrokeJoin();
-				cap = style.getStrokeCap();
-				miterLimit = style.getMiterLimit();
-				strokePadding = strokePadding.add(
-					Path._getStrokePadding(strokeRadius, strokeMatrix));
-			} else {
-				join = cap = 'round';
-			}
-		}
-
-		function isCloseEnough(pt, padding) {
-			return point.subtract(pt).divide(padding).length <= 1;
-		}
-
-		function checkSegmentPoint(seg, pt, name) {
-			if (!options.selected || pt.isSelected()) {
-				var anchor = seg._point;
-				if (pt !== anchor)
-					pt = pt.add(anchor);
-				if (isCloseEnough(pt, strokePadding)) {
-					return new HitResult(name, that, {
-						segment: seg,
-						point: pt
-					});
-				}
-			}
-		}
-
-		function checkSegmentPoints(seg, ends) {
-			return (ends || options.segments)
-				&& checkSegmentPoint(seg, seg._point, 'segment')
-				|| (!ends && options.handles) && (
-					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
-					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
-		}
-
-		function addToArea(point) {
-			area.add(point);
-		}
-
-		function checkSegmentStroke(segment) {
-			var isJoin = closed || segment._index > 0
-					&& segment._index < numSegments - 1;
-			if ((isJoin ? join : cap) === 'round') {
-				return isCloseEnough(segment._point, strokePadding);
-			} else {
-				area = new Path({ internal: true, closed: true });
-				if (isJoin) {
-					if (!segment.isSmooth()) {
-						Path._addBevelJoin(segment, join, strokeRadius,
-							   miterLimit, null, strokeMatrix, addToArea, true);
-					}
-				} else if (cap === 'square') {
-					Path._addSquareCap(segment, cap, strokeRadius, null,
-							strokeMatrix, addToArea, true);
-				}
-				if (!area.isEmpty()) {
-					var loc;
-					return area.contains(point)
-						|| (loc = area.getNearestLocation(point))
-							&& isCloseEnough(loc.getPoint(), tolerancePadding);
-				}
-			}
-		}
-
-		if (options.ends && !options.segments && !closed) {
-			if (res = checkSegmentPoints(segments[0], true)
-					|| checkSegmentPoints(segments[numSegments - 1], true))
-				return res;
-		} else if (options.segments || options.handles) {
-			for (var i = 0; i < numSegments; i++)
-				if (res = checkSegmentPoints(segments[i]))
-					return res;
-		}
-		if (strokeRadius !== null) {
-			loc = this.getNearestLocation(point);
-			if (loc) {
-				var time = loc.getTime();
-				if (time === 0 || time === 1 && numSegments > 1) {
-					if (!checkSegmentStroke(loc.getSegment()))
-						loc = null;
-				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
-					loc = null;
-				}
-			}
-			if (!loc && join === 'miter' && numSegments > 1) {
-				for (var i = 0; i < numSegments; i++) {
-					var segment = segments[i];
-					if (point.getDistance(segment._point)
-							<= miterLimit * strokeRadius
-							&& checkSegmentStroke(segment)) {
-						loc = segment.getLocation();
-						break;
-					}
-				}
-			}
-		}
-		return !loc && hitFill && this._contains(point)
-				|| loc && !hitStroke && !hitCurves
-					? new HitResult('fill', this)
-					: loc
-						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
-							location: loc,
-							point: loc.getPoint()
-						})
-						: null;
-	}
-
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var loc = this.getLocationAt(offset);
-			return loc && loc[name]();
-		};
-	},
-{
-	beans: false,
-
-	getLocationOf: function() {
-		var point = Point.read(arguments),
-			curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var loc = curves[i].getLocationOf(point);
-			if (loc)
-				return loc;
-		}
-		return null;
-	},
-
-	getOffsetOf: function() {
-		var loc = this.getLocationOf.apply(this, arguments);
-		return loc ? loc.getOffset() : null;
-	},
-
-	getLocationAt: function(offset) {
-		if (typeof offset === 'number') {
-			var curves = this.getCurves(),
-				length = 0;
-			for (var i = 0, l = curves.length; i < l; i++) {
-				var start = length,
-					curve = curves[i];
-				length += curve.getLength();
-				if (length > offset) {
-					return curve.getLocationAt(offset - start);
-				}
-			}
-			if (curves.length > 0 && offset <= this.getLength()) {
-				return new CurveLocation(curves[curves.length - 1], 1);
-			}
-		} else if (offset && offset.getPath && offset.getPath() === this) {
-			return offset;
-		}
-		return null;
-	},
-
-	getOffsetsWithTangent: function() {
-		var tangent = Point.read(arguments);
-		if (tangent.isZero()) {
-			return [];
-		}
-
-		var offsets = [];
-		var curveStart = 0;
-		var curves = this.getCurves();
-		for (var i = 0, l = curves.length; i < l; i++) {
-			var curve = curves[i];
-			var curveTimes = curve.getTimesWithTangent(tangent);
-			for (var j = 0, m = curveTimes.length; j < m; j++) {
-				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
-				if (offsets.indexOf(offset) < 0) {
-					offsets.push(offset);
-				}
-			}
-			curveStart += curve.length;
-		}
-		return offsets;
-	}
-}),
-new function() {
-
-	function drawHandles(ctx, segments, matrix, size) {
-		if (size <= 0) return;
-
-		var half = size / 2,
-			miniSize = size - 2,
-			miniHalf = half - 1,
-			coords = new Array(6),
-			pX, pY;
-
-		function drawHandle(index) {
-			var hX = coords[index],
-				hY = coords[index + 1];
-			if (pX != hX || pY != hY) {
-				ctx.beginPath();
-				ctx.moveTo(pX, pY);
-				ctx.lineTo(hX, hY);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
-				ctx.fill();
-			}
-		}
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i],
-				selection = segment._selection;
-			segment._transformCoordinates(matrix, coords);
-			pX = coords[0];
-			pY = coords[1];
-			if (selection & 2)
-				drawHandle(2);
-			if (selection & 4)
-				drawHandle(4);
-			ctx.fillRect(pX - half, pY - half, size, size);
-			if (miniSize > 0 && !(selection & 1)) {
-				var fillStyle = ctx.fillStyle;
-				ctx.fillStyle = '#ffffff';
-				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
-				ctx.fillStyle = fillStyle;
-			}
-		}
-	}
-
-	function drawSegments(ctx, path, matrix) {
-		var segments = path._segments,
-			length = segments.length,
-			coords = new Array(6),
-			first = true,
-			curX, curY,
-			prevX, prevY,
-			inX, inY,
-			outX, outY;
-
-		function drawSegment(segment) {
-			if (matrix) {
-				segment._transformCoordinates(matrix, coords);
-				curX = coords[0];
-				curY = coords[1];
-			} else {
-				var point = segment._point;
-				curX = point._x;
-				curY = point._y;
-			}
-			if (first) {
-				ctx.moveTo(curX, curY);
-				first = false;
-			} else {
-				if (matrix) {
-					inX = coords[2];
-					inY = coords[3];
-				} else {
-					var handle = segment._handleIn;
-					inX = curX + handle._x;
-					inY = curY + handle._y;
-				}
-				if (inX === curX && inY === curY
-						&& outX === prevX && outY === prevY) {
-					ctx.lineTo(curX, curY);
-				} else {
-					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
-				}
-			}
-			prevX = curX;
-			prevY = curY;
-			if (matrix) {
-				outX = coords[4];
-				outY = coords[5];
-			} else {
-				var handle = segment._handleOut;
-				outX = prevX + handle._x;
-				outY = prevY + handle._y;
-			}
-		}
-
-		for (var i = 0; i < length; i++)
-			drawSegment(segments[i]);
-		if (path._closed && length > 0)
-			drawSegment(segments[0]);
-	}
-
-	return {
-		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-			var dontStart = param.dontStart,
-				dontPaint = param.dontFinish || param.clip,
-				style = this.getStyle(),
-				hasFill = style.hasFill(),
-				hasStroke = style.hasStroke(),
-				dashArray = style.getDashArray(),
-				dashLength = !paper.support.nativeDash && hasStroke
-						&& dashArray && dashArray.length;
-
-			if (!dontStart)
-				ctx.beginPath();
-
-			if (hasFill || hasStroke && !dashLength || dontPaint) {
-				drawSegments(ctx, this, strokeMatrix);
-				if (this._closed)
-					ctx.closePath();
-			}
-
-			function getOffset(i) {
-				return dashArray[((i % dashLength) + dashLength) % dashLength];
-			}
-
-			if (!dontPaint && (hasFill || hasStroke)) {
-				this._setStyles(ctx, param, viewMatrix);
-				if (hasFill) {
-					ctx.fill(style.getFillRule());
-					ctx.shadowColor = 'rgba(0,0,0,0)';
-				}
-				if (hasStroke) {
-					if (dashLength) {
-						if (!dontStart)
-							ctx.beginPath();
-						var flattener = new PathFlattener(this, 0.25, 32, false,
-								strokeMatrix),
-							length = flattener.length,
-							from = -style.getDashOffset(), to,
-							i = 0;
-						from = from % length;
-						while (from > 0) {
-							from -= getOffset(i--) + getOffset(i--);
-						}
-						while (from < length) {
-							to = from + getOffset(i++);
-							if (from > 0 || to > 0)
-								flattener.drawPart(ctx,
-										Math.max(from, 0), Math.max(to, 0));
-							from = to + getOffset(i++);
-						}
-					}
-					ctx.stroke();
-				}
-			}
-		},
-
-		_drawSelected: function(ctx, matrix) {
-			ctx.beginPath();
-			drawSegments(ctx, this, matrix);
-			ctx.stroke();
-			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
-		}
-	};
-},
-new function() {
-	function getCurrentSegment(that) {
-		var segments = that._segments;
-		if (!segments.length)
-			throw new Error('Use a moveTo() command first');
-		return segments[segments.length - 1];
-	}
-
-	return {
-		moveTo: function() {
-			var segments = this._segments;
-			if (segments.length === 1)
-				this.removeSegment(0);
-			if (!segments.length)
-				this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		moveBy: function() {
-			throw new Error('moveBy() is unsupported on Path items.');
-		},
-
-		lineTo: function() {
-			this._add([ new Segment(Point.read(arguments)) ]);
-		},
-
-		cubicCurveTo: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this);
-			current.setHandleOut(handle1.subtract(current._point));
-			this._add([ new Segment(to, handle2.subtract(to)) ]);
-		},
-
-		quadraticCurveTo: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(
-				handle.add(current.subtract(handle).multiply(1 / 3)),
-				handle.add(to.subtract(handle).multiply(1 / 3)),
-				to
-			);
-		},
-
-		curveTo: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				t = Base.pick(Base.read(args), 0.5),
-				t1 = 1 - t,
-				current = getCurrentSegment(this)._point,
-				handle = through.subtract(current.multiply(t1 * t1))
-					.subtract(to.multiply(t * t)).divide(2 * t * t1);
-			if (handle.isNaN())
-				throw new Error(
-					'Cannot put a curve through points with parameter = ' + t);
-			this.quadraticCurveTo(handle, to);
-		},
-
-		arcTo: function() {
-			var args = arguments,
-				abs = Math.abs,
-				sqrt = Math.sqrt,
-				current = getCurrentSegment(this),
-				from = current._point,
-				to = Point.read(args),
-				through,
-				peek = Base.peek(args),
-				clockwise = Base.pick(peek, true),
-				center, extent, vector, matrix;
-			if (typeof clockwise === 'boolean') {
-				var middle = from.add(to).divide(2),
-				through = middle.add(middle.subtract(from).rotate(
-						clockwise ? -90 : 90));
-			} else if (Base.remain(args) <= 2) {
-				through = to;
-				to = Point.read(args);
-			} else if (!from.equals(to)) {
-				var radius = Size.read(args),
-					isZero = Numerical.isZero;
-				if (isZero(radius.width) || isZero(radius.height))
-					return this.lineTo(to);
-				var rotation = Base.read(args),
-					clockwise = !!Base.read(args),
-					large = !!Base.read(args),
-					middle = from.add(to).divide(2),
-					pt = from.subtract(middle).rotate(-rotation),
-					x = pt.x,
-					y = pt.y,
-					rx = abs(radius.width),
-					ry = abs(radius.height),
-					rxSq = rx * rx,
-					rySq = ry * ry,
-					xSq = x * x,
-					ySq = y * y;
-				var factor = sqrt(xSq / rxSq + ySq / rySq);
-				if (factor > 1) {
-					rx *= factor;
-					ry *= factor;
-					rxSq = rx * rx;
-					rySq = ry * ry;
-				}
-				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
-						(rxSq * ySq + rySq * xSq);
-				if (abs(factor) < 1e-12)
-					factor = 0;
-				if (factor < 0)
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				center = new Point(rx * y / ry, -ry * x / rx)
-						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
-						.rotate(rotation).add(middle);
-				matrix = new Matrix().translate(center).rotate(rotation)
-						.scale(rx, ry);
-				vector = matrix._inverseTransform(from);
-				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
-				if (!clockwise && extent > 0)
-					extent -= 360;
-				else if (clockwise && extent < 0)
-					extent += 360;
-			}
-			if (through) {
-				var l1 = new Line(from.add(through).divide(2),
-							through.subtract(from).rotate(90), true),
-					l2 = new Line(through.add(to).divide(2),
-							to.subtract(through).rotate(90), true),
-					line = new Line(from, to),
-					throughSide = line.getSide(through);
-				center = l1.intersect(l2, true);
-				if (!center) {
-					if (!throughSide)
-						return this.lineTo(to);
-					throw new Error(
-							'Cannot create an arc with the given arguments');
-				}
-				vector = from.subtract(center);
-				extent = vector.getDirectedAngle(to.subtract(center));
-				var centerSide = line.getSide(center, true);
-				if (centerSide === 0) {
-					extent = throughSide * abs(extent);
-				} else if (throughSide === centerSide) {
-					extent += extent < 0 ? 360 : -360;
-				}
-			}
-			if (extent) {
-				var epsilon = 1e-7,
-					ext = abs(extent),
-					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
-					inc = extent / count,
-					half = inc * Math.PI / 360,
-					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
-					segments = [];
-				for (var i = 0; i <= count; i++) {
-					var pt = to,
-						out = null;
-					if (i < count) {
-						out = vector.rotate(90).multiply(z);
-						if (matrix) {
-							pt = matrix._transformPoint(vector);
-							out = matrix._transformPoint(vector.add(out))
-									.subtract(pt);
-						} else {
-							pt = center.add(vector);
-						}
-					}
-					if (!i) {
-						current.setHandleOut(out);
-					} else {
-						var _in = vector.rotate(-90).multiply(z);
-						if (matrix) {
-							_in = matrix._transformPoint(vector.add(_in))
-									.subtract(pt);
-						}
-						segments.push(new Segment(pt, _in, out));
-					}
-					vector = vector.rotate(inc);
-				}
-				this._add(segments);
-			}
-		},
-
-		lineBy: function() {
-			var to = Point.read(arguments),
-				current = getCurrentSegment(this)._point;
-			this.lineTo(current.add(to));
-		},
-
-		curveBy: function() {
-			var args = arguments,
-				through = Point.read(args),
-				to = Point.read(args),
-				parameter = Base.read(args),
-				current = getCurrentSegment(this)._point;
-			this.curveTo(current.add(through), current.add(to), parameter);
-		},
-
-		cubicCurveBy: function() {
-			var args = arguments,
-				handle1 = Point.read(args),
-				handle2 = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.cubicCurveTo(current.add(handle1), current.add(handle2),
-					current.add(to));
-		},
-
-		quadraticCurveBy: function() {
-			var args = arguments,
-				handle = Point.read(args),
-				to = Point.read(args),
-				current = getCurrentSegment(this)._point;
-			this.quadraticCurveTo(current.add(handle), current.add(to));
-		},
-
-		arcBy: function() {
-			var args = arguments,
-				current = getCurrentSegment(this)._point,
-				point = current.add(Point.read(args)),
-				clockwise = Base.pick(Base.peek(args), true);
-			if (typeof clockwise === 'boolean') {
-				this.arcTo(point, clockwise);
-			} else {
-				this.arcTo(point, current.add(Point.read(args)));
-			}
-		},
-
-		closePath: function(tolerance) {
-			this.setClosed(true);
-			this.join(this, tolerance);
-		}
-	};
-}, {
-
-	_getBounds: function(matrix, options) {
-		var method = options.handle
-				? 'getHandleBounds'
-				: options.stroke
-				? 'getStrokeBounds'
-				: 'getBounds';
-		return Path[method](this._segments, this._closed, this, matrix, options);
-	},
-
-statics: {
-	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
-		var first = segments[0];
-		if (!first)
-			return new Rectangle();
-		var coords = new Array(6),
-			prevCoords = first._transformCoordinates(matrix, new Array(6)),
-			min = prevCoords.slice(0, 2),
-			max = min.slice(),
-			roots = new Array(2);
-
-		function processSegment(segment) {
-			segment._transformCoordinates(matrix, coords);
-			for (var i = 0; i < 2; i++) {
-				Curve._addBounds(
-					prevCoords[i],
-					prevCoords[i + 4],
-					coords[i + 2],
-					coords[i],
-					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
-			}
-			var tmp = prevCoords;
-			prevCoords = coords;
-			coords = tmp;
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++)
-			processSegment(segments[i]);
-		if (closed)
-			processSegment(first);
-		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
-	},
-
-	getStrokeBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = style.hasStroke(),
-			strokeWidth = style.getStrokeWidth(),
-			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
-			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
-				strokeMatrix),
-			bounds = Path.getBounds(segments, closed, path, matrix, options,
-				strokePadding);
-		if (!stroke)
-			return bounds;
-		var strokeRadius = strokeWidth / 2,
-			join = style.getStrokeJoin(),
-			cap = style.getStrokeCap(),
-			miterLimit = style.getMiterLimit(),
-			joinBounds = new Rectangle(new Size(strokePadding));
-
-		function addPoint(point) {
-			bounds = bounds.include(point);
-		}
-
-		function addRound(segment) {
-			bounds = bounds.unite(
-					joinBounds.setCenter(segment._point.transform(matrix)));
-		}
-
-		function addJoin(segment, join) {
-			if (join === 'round' || segment.isSmooth()) {
-				addRound(segment);
-			} else {
-				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
-						matrix, strokeMatrix, addPoint);
-			}
-		}
-
-		function addCap(segment, cap) {
-			if (cap === 'round') {
-				addRound(segment);
-			} else {
-				Path._addSquareCap(segment, cap, strokeRadius, matrix,
-						strokeMatrix, addPoint);
-			}
-		}
-
-		var length = segments.length - (closed ? 0 : 1);
-		if (length > 0) {
-			for (var i = 1; i < length; i++) {
-				addJoin(segments[i], join);
-			}
-			if (closed) {
-				addJoin(segments[0], join);
-			} else {
-				addCap(segments[0], cap);
-				addCap(segments[segments.length - 1], cap);
-			}
-		}
-		return bounds;
-	},
-
-	_getStrokePadding: function(radius, matrix) {
-		if (!matrix)
-			return [radius, radius];
-		var hor = new Point(radius, 0).transform(matrix),
-			ver = new Point(0, radius).transform(matrix),
-			phi = hor.getAngleInRadians(),
-			a = hor.getLength(),
-			b = ver.getLength();
-		var sin = Math.sin(phi),
-			cos = Math.cos(phi),
-			tan = Math.tan(phi),
-			tx = Math.atan2(b * tan, a),
-			ty = Math.atan2(b, tan * a);
-		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
-				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
-	},
-
-	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
-			strokeMatrix, addPoint, isArea) {
-		var curve2 = segment.getCurve(),
-			curve1 = curve2.getPrevious(),
-			point = curve2.getPoint1().transform(matrix),
-			normal1 = curve1.getNormalAtTime(1).multiply(radius)
-				.transform(strokeMatrix),
-			normal2 = curve2.getNormalAtTime(0).multiply(radius)
-				.transform(strokeMatrix),
-				angle = normal1.getDirectedAngle(normal2);
-		if (angle < 0 || angle >= 180) {
-			normal1 = normal1.negate();
-			normal2 = normal2.negate();
-		}
-		if (isArea)
-			addPoint(point);
-		addPoint(point.add(normal1));
-		if (join === 'miter') {
-			var corner = new Line(point.add(normal1),
-					new Point(-normal1.y, normal1.x), true
-				).intersect(new Line(point.add(normal2),
-					new Point(-normal2.y, normal2.x), true
-				), true);
-			if (corner && point.getDistance(corner) <= miterLimit * radius) {
-				addPoint(corner);
-			}
-		}
-		addPoint(point.add(normal2));
-	},
-
-	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
-			addPoint, isArea) {
-		var point = segment._point.transform(matrix),
-			loc = segment.getLocation(),
-			normal = loc.getNormal()
-					.multiply(loc.getTime() === 0 ? radius : -radius)
-					.transform(strokeMatrix);
-		if (cap === 'square') {
-			if (isArea) {
-				addPoint(point.subtract(normal));
-				addPoint(point.add(normal));
-			}
-			point = point.add(normal.rotate(-90));
-		}
-		addPoint(point.add(normal));
-		addPoint(point.subtract(normal));
-	},
-
-	getHandleBounds: function(segments, closed, path, matrix, options) {
-		var style = path.getStyle(),
-			stroke = options.stroke && style.hasStroke(),
-			strokePadding,
-			joinPadding;
-		if (stroke) {
-			var strokeMatrix = path._getStrokeMatrix(matrix, options),
-				strokeRadius = style.getStrokeWidth() / 2,
-				joinRadius = strokeRadius;
-			if (style.getStrokeJoin() === 'miter')
-				joinRadius = strokeRadius * style.getMiterLimit();
-			if (style.getStrokeCap() === 'square')
-				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
-			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
-			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
-		}
-		var coords = new Array(6),
-			x1 = Infinity,
-			x2 = -x1,
-			y1 = x1,
-			y2 = x2;
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var segment = segments[i];
-			segment._transformCoordinates(matrix, coords);
-			for (var j = 0; j < 6; j += 2) {
-				var padding = !j ? joinPadding : strokePadding,
-					paddingX = padding ? padding[0] : 0,
-					paddingY = padding ? padding[1] : 0,
-					x = coords[j],
-					y = coords[j + 1],
-					xn = x - paddingX,
-					xx = x + paddingX,
-					yn = y - paddingY,
-					yx = y + paddingY;
-				if (xn < x1) x1 = xn;
-				if (xx > x2) x2 = xx;
-				if (yn < y1) y1 = yn;
-				if (yx > y2) y2 = yx;
-			}
-		}
-		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
-	}
-}});
-
-Path.inject({ statics: new function() {
-
-	var kappa = 0.5522847498307936,
-		ellipseSegments = [
-			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
-			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
-			new Segment([1, 0], [0, -kappa], [0, kappa ]),
-			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
-		];
-
-	function createPath(segments, closed, args) {
-		var props = Base.getNamed(args),
-			path = new Path(props && props.insert == false && Item.NO_INSERT);
-		path._add(segments);
-		path._closed = closed;
-		return path.set(props, { insert: true });
-	}
-
-	function createEllipse(center, radius, args) {
-		var segments = new Array(4);
-		for (var i = 0; i < 4; i++) {
-			var segment = ellipseSegments[i];
-			segments[i] = new Segment(
-				segment._point.multiply(radius).add(center),
-				segment._handleIn.multiply(radius),
-				segment._handleOut.multiply(radius)
-			);
-		}
-		return createPath(segments, true, args);
-	}
-
-	return {
-		Line: function() {
-			var args = arguments;
-			return createPath([
-				new Segment(Point.readNamed(args, 'from')),
-				new Segment(Point.readNamed(args, 'to'))
-			], false, args);
-		},
-
-		Circle: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				radius = Base.readNamed(args, 'radius');
-			return createEllipse(center, new Size(radius), args);
-		},
-
-		Rectangle: function() {
-			var args = arguments,
-				rect = Rectangle.readNamed(args, 'rectangle'),
-				radius = Size.readNamed(args, 'radius', 0,
-						{ readNull: true }),
-				bl = rect.getBottomLeft(true),
-				tl = rect.getTopLeft(true),
-				tr = rect.getTopRight(true),
-				br = rect.getBottomRight(true),
-				segments;
-			if (!radius || radius.isZero()) {
-				segments = [
-					new Segment(bl),
-					new Segment(tl),
-					new Segment(tr),
-					new Segment(br)
-				];
-			} else {
-				radius = Size.min(radius, rect.getSize(true).divide(2));
-				var rx = radius.width,
-					ry = radius.height,
-					hx = rx * kappa,
-					hy = ry * kappa;
-				segments = [
-					new Segment(bl.add(rx, 0), null, [-hx, 0]),
-					new Segment(bl.subtract(0, ry), [0, hy]),
-					new Segment(tl.add(0, ry), null, [0, -hy]),
-					new Segment(tl.add(rx, 0), [-hx, 0], null),
-					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
-					new Segment(tr.add(0, ry), [0, -hy], null),
-					new Segment(br.subtract(0, ry), null, [0, hy]),
-					new Segment(br.subtract(rx, 0), [hx, 0])
-				];
-			}
-			return createPath(segments, true, args);
-		},
-
-		RoundRectangle: '#Rectangle',
-
-		Ellipse: function() {
-			var args = arguments,
-				ellipse = Shape._readEllipse(args);
-			return createEllipse(ellipse.center, ellipse.radius, args);
-		},
-
-		Oval: '#Ellipse',
-
-		Arc: function() {
-			var args = arguments,
-				from = Point.readNamed(args, 'from'),
-				through = Point.readNamed(args, 'through'),
-				to = Point.readNamed(args, 'to'),
-				props = Base.getNamed(args),
-				path = new Path(props && props.insert == false
-						&& Item.NO_INSERT);
-			path.moveTo(from);
-			path.arcTo(through, to);
-			return path.set(props);
-		},
-
-		RegularPolygon: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				sides = Base.readNamed(args, 'sides'),
-				radius = Base.readNamed(args, 'radius'),
-				step = 360 / sides,
-				three = sides % 3 === 0,
-				vector = new Point(0, three ? -radius : radius),
-				offset = three ? -1 : 0.5,
-				segments = new Array(sides);
-			for (var i = 0; i < sides; i++)
-				segments[i] = new Segment(center.add(
-					vector.rotate((i + offset) * step)));
-			return createPath(segments, true, args);
-		},
-
-		Star: function() {
-			var args = arguments,
-				center = Point.readNamed(args, 'center'),
-				points = Base.readNamed(args, 'points') * 2,
-				radius1 = Base.readNamed(args, 'radius1'),
-				radius2 = Base.readNamed(args, 'radius2'),
-				step = 360 / points,
-				vector = new Point(0, -1),
-				segments = new Array(points);
-			for (var i = 0; i < points; i++)
-				segments[i] = new Segment(center.add(vector.rotate(step * i)
-						.multiply(i % 2 ? radius2 : radius1)));
-			return createPath(segments, true, args);
-		}
-	};
-}});
-
-var CompoundPath = PathItem.extend({
-	_class: 'CompoundPath',
-	_serializeFields: {
-		children: []
-	},
-	beans: true,
-
-	initialize: function CompoundPath(arg) {
-		this._children = [];
-		this._namedChildren = {};
-		if (!this._initialize(arg)) {
-			if (typeof arg === 'string') {
-				this.setPathData(arg);
-			} else {
-				this.addChildren(Array.isArray(arg) ? arg : arguments);
-			}
-		}
-	},
-
-	insertChildren: function insertChildren(index, items) {
-		var list = items,
-			first = list[0];
-		if (first && typeof first[0] === 'number')
-			list = [list];
-		for (var i = items.length - 1; i >= 0; i--) {
-			var item = list[i];
-			if (list === items && !(item instanceof Path))
-				list = Base.slice(list);
-			if (Array.isArray(item)) {
-				list[i] = new Path({ segments: item, insert: false });
-			} else if (item instanceof CompoundPath) {
-				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
-				item.remove();
-			}
-		}
-		return insertChildren.base.call(this, index, list);
-	},
-
-	reduce: function reduce(options) {
-		var children = this._children;
-		for (var i = children.length - 1; i >= 0; i--) {
-			var path = children[i].reduce(options);
-			if (path.isEmpty())
-				path.remove();
-		}
-		if (!children.length) {
-			var path = new Path(Item.NO_INSERT);
-			path.copyAttributes(this);
-			path.insertAbove(this);
-			this.remove();
-			return path;
-		}
-		return reduce.base.call(this);
-	},
-
-	isClosed: function() {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			if (!children[i]._closed)
-				return false;
-		}
-		return true;
-	},
-
-	setClosed: function(closed) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			children[i].setClosed(closed);
-		}
-	},
-
-	getFirstSegment: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstSegment();
-	},
-
-	getLastSegment: function() {
-		var last = this.getLastChild();
-		return last && last.getLastSegment();
-	},
-
-	getCurves: function() {
-		var children = this._children,
-			curves = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			Base.push(curves, children[i].getCurves());
-		}
-		return curves;
-	},
-
-	getFirstCurve: function() {
-		var first = this.getFirstChild();
-		return first && first.getFirstCurve();
-	},
-
-	getLastCurve: function() {
-		var last = this.getLastChild();
-		return last && last.getLastCurve();
-	},
-
-	getArea: function() {
-		var children = this._children,
-			area = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			area += children[i].getArea();
-		return area;
-	},
-
-	getLength: function() {
-		var children = this._children,
-			length = 0;
-		for (var i = 0, l = children.length; i < l; i++)
-			length += children[i].getLength();
-		return length;
-	},
-
-	getPathData: function(_matrix, _precision) {
-		var children = this._children,
-			paths = [];
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			paths.push(child.getPathData(_matrix && !mx.isIdentity()
-					? _matrix.appended(mx) : _matrix, _precision));
-		}
-		return paths.join('');
-	},
-
-	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
-		return _hitTestChildren.base.call(this, point,
-				options.class === Path || options.type === 'path' ? options
-					: Base.set({}, options, { fill: false }),
-				viewMatrix);
-	},
-
-	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
-		var children = this._children;
-		if (!children.length)
-			return;
-
-		param = param.extend({ dontStart: true, dontFinish: true });
-		ctx.beginPath();
-		for (var i = 0, l = children.length; i < l; i++)
-			children[i].draw(ctx, param, strokeMatrix);
-
-		if (!param.clip) {
-			this._setStyles(ctx, param, viewMatrix);
-			var style = this._style;
-			if (style.hasFill()) {
-				ctx.fill(style.getFillRule());
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (style.hasStroke())
-				ctx.stroke();
-		}
-	},
-
-	_drawSelected: function(ctx, matrix, selectionItems) {
-		var children = this._children;
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i],
-				mx = child._matrix;
-			if (!selectionItems[child._id]) {
-				child._drawSelected(ctx, mx.isIdentity() ? matrix
-						: matrix.appended(mx));
-			}
-		}
-	}
-},
-new function() {
-	function getCurrentPath(that, check) {
-		var children = that._children;
-		if (check && !children.length)
-			throw new Error('Use a moveTo() command first');
-		return children[children.length - 1];
-	}
-
-	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
-			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
-			'arcBy'],
-		function(key) {
-			this[key] = function() {
-				var path = getCurrentPath(this, true);
-				path[key].apply(path, arguments);
-			};
-		}, {
-			moveTo: function() {
-				var current = getCurrentPath(this),
-					path = current && current.isEmpty() ? current
-							: new Path(Item.NO_INSERT);
-				if (path !== current)
-					this.addChild(path);
-				path.moveTo.apply(path, arguments);
-			},
-
-			moveBy: function() {
-				var current = getCurrentPath(this, true),
-					last = current && current.getLastSegment(),
-					point = Point.read(arguments);
-				this.moveTo(last ? point.add(last._point) : point);
-			},
-
-			closePath: function(tolerance) {
-				getCurrentPath(this, true).closePath(tolerance);
-			}
-		}
-	);
-}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
-	this[key] = function(param) {
-		var children = this._children,
-			res;
-		for (var i = 0, l = children.length; i < l; i++) {
-			res = children[i][key](param) || res;
-		}
-		return res;
-	};
-}, {}));
-
-PathItem.inject(new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		operators = {
-			unite:     { '1': true, '2': true },
-			intersect: { '2': true },
-			subtract:  { '1': true },
-			exclude:   { '1': true, '-1': true }
-		};
-
-	function getPaths(path) {
-		return path._children || [path];
-	}
-
-	function preparePath(path, resolve) {
-		var res = path
-			.clone(false)
-			.reduce({ simplify: true })
-			.transform(null, true, true);
-		if (resolve) {
-			var paths = getPaths(res);
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				if (!path._closed && !path.isEmpty()) {
-					path.closePath(1e-12);
-					path.getFirstSegment().setHandleIn(0, 0);
-					path.getLastSegment().setHandleOut(0, 0);
-				}
-			}
-			res = res
-				.resolveCrossings()
-				.reorient(res.getFillRule() === 'nonzero', true);
-		}
-		return res;
-	}
-
-	function createResult(paths, simplify, path1, path2, options) {
-		var result = new CompoundPath(Item.NO_INSERT);
-		result.addChildren(paths, true);
-		result = result.reduce({ simplify: simplify });
-		if (!(options && options.insert == false)) {
-			result.insertAbove(path2 && path1.isSibling(path2)
-					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
-		}
-		result.copyAttributes(path1, true);
-		return result;
-	}
-
-	function filterIntersection(inter) {
-		return inter.hasOverlap() || inter.isCrossing();
-	}
-
-	function traceBoolean(path1, path2, operation, options) {
-		if (options && (options.trace == false || options.stroke) &&
-				/^(subtract|intersect)$/.test(operation))
-			return splitBoolean(path1, path2, operation);
-		var _path1 = preparePath(path1, true),
-			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
-			operator = operators[operation];
-		operator[operation] = true;
-		if (_path2 && (operator.subtract || operator.exclude)
-				^ (_path2.isClockwise() ^ _path1.isClockwise()))
-			_path2.reverse();
-		var crossings = divideLocations(CurveLocation.expand(
-				_path1.getIntersections(_path2, filterIntersection))),
-			paths1 = getPaths(_path1),
-			paths2 = _path2 && getPaths(_path2),
-			segments = [],
-			curves = [],
-			paths;
-
-		function collectPaths(paths) {
-			for (var i = 0, l = paths.length; i < l; i++) {
-				var path = paths[i];
-				Base.push(segments, path._segments);
-				Base.push(curves, path.getCurves());
-				path._overlapsOnly = true;
-			}
-		}
-
-		function getCurves(indices) {
-			var list = [];
-			for (var i = 0, l = indices && indices.length; i < l; i++) {
-				list.push(curves[indices[i]]);
-			}
-			return list;
-		}
-
-		if (crossings.length) {
-			collectPaths(paths1);
-			if (paths2)
-				collectPaths(paths2);
-
-			var curvesValues = new Array(curves.length);
-			for (var i = 0, l = curves.length; i < l; i++) {
-				curvesValues[i] = curves[i].getValues();
-			}
-			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
-					curvesValues, curvesValues, 0, true);
-			var curveCollisionsMap = {};
-			for (var i = 0; i < curves.length; i++) {
-				var curve = curves[i],
-					id = curve._path._id,
-					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
-				map[curve.getIndex()] = {
-					hor: getCurves(curveCollisions[i].hor),
-					ver: getCurves(curveCollisions[i].ver)
-				};
-			}
-
-			for (var i = 0, l = crossings.length; i < l; i++) {
-				propagateWinding(crossings[i]._segment, _path1, _path2,
-						curveCollisionsMap, operator);
-			}
-			for (var i = 0, l = segments.length; i < l; i++) {
-				var segment = segments[i],
-					inter = segment._intersection;
-				if (!segment._winding) {
-					propagateWinding(segment, _path1, _path2,
-							curveCollisionsMap, operator);
-				}
-				if (!(inter && inter._overlap))
-					segment._path._overlapsOnly = false;
-			}
-			paths = tracePaths(segments, operator);
-		} else {
-			paths = reorientPaths(
-					paths2 ? paths1.concat(paths2) : paths1.slice(),
-					function(w) {
-						return !!operator[w];
-					});
-		}
-		return createResult(paths, true, path1, path2, options);
-	}
-
-	function splitBoolean(path1, path2, operation) {
-		var _path1 = preparePath(path1),
-			_path2 = preparePath(path2),
-			crossings = _path1.getIntersections(_path2, filterIntersection),
-			subtract = operation === 'subtract',
-			divide = operation === 'divide',
-			added = {},
-			paths = [];
-
-		function addPath(path) {
-			if (!added[path._id] && (divide ||
-					_path2.contains(path.getPointAt(path.getLength() / 2))
-						^ subtract)) {
-				paths.unshift(path);
-				return added[path._id] = true;
-			}
-		}
-
-		for (var i = crossings.length - 1; i >= 0; i--) {
-			var path = crossings[i].split();
-			if (path) {
-				if (addPath(path))
-					path.getFirstSegment().setHandleIn(0, 0);
-				_path1.getLastSegment().setHandleOut(0, 0);
-			}
-		}
-		addPath(_path1);
-		return createResult(paths, false, path1, path2);
-	}
-
-	function linkIntersections(from, to) {
-		var prev = from;
-		while (prev) {
-			if (prev === to)
-				return;
-			prev = prev._previous;
-		}
-		while (from._next && from._next !== to)
-			from = from._next;
-		if (!from._next) {
-			while (to._previous)
-				to = to._previous;
-			from._next = to;
-			to._previous = from;
-		}
-	}
-
-	function clearCurveHandles(curves) {
-		for (var i = curves.length - 1; i >= 0; i--)
-			curves[i].clearHandles();
-	}
-
-	function reorientPaths(paths, isInside, clockwise) {
-		var length = paths && paths.length;
-		if (length) {
-			var lookup = Base.each(paths, function (path, i) {
-					this[path._id] = {
-						container: null,
-						winding: path.isClockwise() ? 1 : -1,
-						index: i
-					};
-				}, {}),
-				sorted = paths.slice().sort(function (a, b) {
-					return abs(b.getArea()) - abs(a.getArea());
-				}),
-				first = sorted[0];
-			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
-					null, Numerical.GEOMETRIC_EPSILON);
-			if (clockwise == null)
-				clockwise = first.isClockwise();
-			for (var i = 0; i < length; i++) {
-				var path1 = sorted[i],
-					entry1 = lookup[path1._id],
-					containerWinding = 0,
-					indices = collisions[i];
-				if (indices) {
-					var point = null;
-					for (var j = indices.length - 1; j >= 0; j--) {
-						if (indices[j] < i) {
-							point = point || path1.getInteriorPoint();
-							var path2 = sorted[indices[j]];
-							if (path2.contains(point)) {
-								var entry2 = lookup[path2._id];
-								containerWinding = entry2.winding;
-								entry1.winding += containerWinding;
-								entry1.container = entry2.exclude
-									? entry2.container : path2;
-								break;
-							}
-						}
-					}
-				}
-				if (isInside(entry1.winding) === isInside(containerWinding)) {
-					entry1.exclude = true;
-					paths[entry1.index] = null;
-				} else {
-					var container = entry1.container;
-					path1.setClockwise(
-							container ? !container.isClockwise() : clockwise);
-				}
-			}
-		}
-		return paths;
-	}
-
-	function divideLocations(locations, include, clearLater) {
-		var results = include && [],
-			tMin = 1e-8,
-			tMax = 1 - tMin,
-			clearHandles = false,
-			clearCurves = clearLater || [],
-			clearLookup = clearLater && {},
-			renormalizeLocs,
-			prevCurve,
-			prevTime;
-
-		function getId(curve) {
-			return curve._path._id + '.' + curve._segment1._index;
-		}
-
-		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
-			var curve = clearLater[i];
-			if (curve._path)
-				clearLookup[getId(curve)] = true;
-		}
-
-		for (var i = locations.length - 1; i >= 0; i--) {
-			var loc = locations[i],
-				time = loc._time,
-				origTime = time,
-				exclude = include && !include(loc),
-				curve = loc._curve,
-				segment;
-			if (curve) {
-				if (curve !== prevCurve) {
-					clearHandles = !curve.hasHandles()
-							|| clearLookup && clearLookup[getId(curve)];
-					renormalizeLocs = [];
-					prevTime = null;
-					prevCurve = curve;
-				} else if (prevTime >= tMin) {
-					time /= prevTime;
-				}
-			}
-			if (exclude) {
-				if (renormalizeLocs)
-					renormalizeLocs.push(loc);
-				continue;
-			} else if (include) {
-				results.unshift(loc);
-			}
-			prevTime = origTime;
-			if (time < tMin) {
-				segment = curve._segment1;
-			} else if (time > tMax) {
-				segment = curve._segment2;
-			} else {
-				var newCurve = curve.divideAtTime(time, true);
-				if (clearHandles)
-					clearCurves.push(curve, newCurve);
-				segment = newCurve._segment1;
-				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
-					var l = renormalizeLocs[j];
-					l._time = (l._time - time) / (1 - time);
-				}
-			}
-			loc._setSegment(segment);
-			var inter = segment._intersection,
-				dest = loc._intersection;
-			if (inter) {
-				linkIntersections(inter, dest);
-				var other = inter;
-				while (other) {
-					linkIntersections(other._intersection, inter);
-					other = other._next;
-				}
-			} else {
-				segment._intersection = dest;
-			}
-		}
-		if (!clearLater)
-			clearCurveHandles(clearCurves);
-		return results || locations;
-	}
-
-	function getWinding(point, curves, dir, closed, dontFlip) {
-		var curvesList = Array.isArray(curves)
-			? curves
-			: curves[dir ? 'hor' : 'ver'];
-		var ia = dir ? 1 : 0,
-			io = ia ^ 1,
-			pv = [point.x, point.y],
-			pa = pv[ia],
-			po = pv[io],
-			windingEpsilon = 1e-9,
-			qualityEpsilon = 1e-6,
-			paL = pa - windingEpsilon,
-			paR = pa + windingEpsilon,
-			windingL = 0,
-			windingR = 0,
-			pathWindingL = 0,
-			pathWindingR = 0,
-			onPath = false,
-			onAnyPath = false,
-			quality = 1,
-			roots = [],
-			vPrev,
-			vClose;
-
-		function addWinding(v) {
-			var o0 = v[io + 0],
-				o3 = v[io + 6];
-			if (po < min(o0, o3) || po > max(o0, o3)) {
-				return;
-			}
-			var a0 = v[ia + 0],
-				a1 = v[ia + 2],
-				a2 = v[ia + 4],
-				a3 = v[ia + 6];
-			if (o0 === o3) {
-				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
-					onPath = true;
-				}
-				return;
-			}
-			var t =   po === o0 ? 0
-					: po === o3 ? 1
-					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
-					? 1
-					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
-						? roots[0]
-						: 1,
-				a =   t === 0 ? a0
-					: t === 1 ? a3
-					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
-				winding = o0 > o3 ? 1 : -1,
-				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
-				a3Prev = vPrev[ia + 6];
-			if (po !== o0) {
-				if (a < paL) {
-					pathWindingL += winding;
-				} else if (a > paR) {
-					pathWindingR += winding;
-				} else {
-					onPath = true;
-				}
-				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
-					quality /= 2;
-			} else {
-				if (winding !== windingPrev) {
-					if (a0 < paL) {
-						pathWindingL += winding;
-					} else if (a0 > paR) {
-						pathWindingR += winding;
-					}
-				} else if (a0 != a3Prev) {
-					if (a3Prev < paR && a > paR) {
-						pathWindingR += winding;
-						onPath = true;
-					} else if (a3Prev > paL && a < paL) {
-						pathWindingL += winding;
-						onPath = true;
-					}
-				}
-				quality /= 4;
-			}
-			vPrev = v;
-			return !dontFlip && a > paL && a < paR
-					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
-					&& getWinding(point, curves, !dir, closed, true);
-		}
-
-		function handleCurve(v) {
-			var o0 = v[io + 0],
-				o1 = v[io + 2],
-				o2 = v[io + 4],
-				o3 = v[io + 6];
-			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
-				var a0 = v[ia + 0],
-					a1 = v[ia + 2],
-					a2 = v[ia + 4],
-					a3 = v[ia + 6],
-					monoCurves = paL > max(a0, a1, a2, a3) ||
-								 paR < min(a0, a1, a2, a3)
-							? [v] : Curve.getMonoCurves(v, dir),
-					res;
-				for (var i = 0, l = monoCurves.length; i < l; i++) {
-					if (res = addWinding(monoCurves[i]))
-						return res;
-				}
-			}
-		}
-
-		for (var i = 0, l = curvesList.length; i < l; i++) {
-			var curve = curvesList[i],
-				path = curve._path,
-				v = curve.getValues(),
-				res;
-			if (!i || curvesList[i - 1]._path !== path) {
-				vPrev = null;
-				if (!path._closed) {
-					vClose = Curve.getValues(
-							path.getLastCurve().getSegment2(),
-							curve.getSegment1(),
-							null, !closed);
-					if (vClose[io] !== vClose[io + 6]) {
-						vPrev = vClose;
-					}
-				}
-
-				if (!vPrev) {
-					vPrev = v;
-					var prev = path.getLastCurve();
-					while (prev && prev !== curve) {
-						var v2 = prev.getValues();
-						if (v2[io] !== v2[io + 6]) {
-							vPrev = v2;
-							break;
-						}
-						prev = prev.getPrevious();
-					}
-				}
-			}
-
-			if (res = handleCurve(v))
-				return res;
-
-			if (i + 1 === l || curvesList[i + 1]._path !== path) {
-				if (vClose && (res = handleCurve(vClose)))
-					return res;
-				if (onPath && !pathWindingL && !pathWindingR) {
-					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
-							? 1 : -1;
-				}
-				windingL += pathWindingL;
-				windingR += pathWindingR;
-				pathWindingL = pathWindingR = 0;
-				if (onPath) {
-					onAnyPath = true;
-					onPath = false;
-				}
-				vClose = null;
-			}
-		}
-		windingL = abs(windingL);
-		windingR = abs(windingR);
-		return {
-			winding: max(windingL, windingR),
-			windingL: windingL,
-			windingR: windingR,
-			quality: quality,
-			onPath: onAnyPath
-		};
-	}
-
-	function propagateWinding(segment, path1, path2, curveCollisionsMap,
-			operator) {
-		var chain = [],
-			start = segment,
-			totalLength = 0,
-			winding;
-		do {
-			var curve = segment.getCurve();
-			if (curve) {
-				var length = curve.getLength();
-				chain.push({ segment: segment, curve: curve, length: length });
-				totalLength += length;
-			}
-			segment = segment.getNext();
-		} while (segment && !segment._intersection && segment !== start);
-		var offsets = [0.5, 0.25, 0.75],
-			winding = { winding: 0, quality: -1 },
-			tMin = 1e-3,
-			tMax = 1 - tMin;
-		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
-			var length = totalLength * offsets[i];
-			for (var j = 0, l = chain.length; j < l; j++) {
-				var entry = chain[j],
-					curveLength = entry.length;
-				if (length <= curveLength) {
-					var curve = entry.curve,
-						path = curve._path,
-						parent = path._parent,
-						operand = parent instanceof CompoundPath ? parent : path,
-						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
-						pt = curve.getPointAtTime(t),
-						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
-					var wind = null;
-					if (operator.subtract && path2) {
-						var otherPath = operand === path1 ? path2 : path1,
-							pathWinding = otherPath._getWinding(pt, dir, true);
-						if (operand === path1 && pathWinding.winding ||
-							operand === path2 && !pathWinding.winding) {
-							if (pathWinding.quality < 1) {
-								continue;
-							} else {
-								wind = { winding: 0, quality: 1 };
-							}
-						}
-					}
-					wind =  wind || getWinding(
-							pt, curveCollisionsMap[path._id][curve.getIndex()],
-							dir, true);
-					if (wind.quality > winding.quality)
-						winding = wind;
-					break;
-				}
-				length -= curveLength;
-			}
-		}
-		for (var j = chain.length - 1; j >= 0; j--) {
-			chain[j].segment._winding = winding;
-		}
-	}
-
-	function tracePaths(segments, operator) {
-		var paths = [],
-			starts;
-
-		function isValid(seg) {
-			var winding;
-			return !!(seg && !seg._visited && (!operator
-					|| operator[(winding = seg._winding || {}).winding]
-						&& !(operator.unite && winding.winding === 2
-							&& winding.windingL && winding.windingR)));
-		}
-
-		function isStart(seg) {
-			if (seg) {
-				for (var i = 0, l = starts.length; i < l; i++) {
-					if (seg === starts[i])
-						return true;
-				}
-			}
-			return false;
-		}
-
-		function visitPath(path) {
-			var segments = path._segments;
-			for (var i = 0, l = segments.length; i < l; i++) {
-				segments[i]._visited = true;
-			}
-		}
-
-		function getCrossingSegments(segment, collectStarts) {
-			var inter = segment._intersection,
-				start = inter,
-				crossings = [];
-			if (collectStarts)
-				starts = [segment];
-
-			function collect(inter, end) {
-				while (inter && inter !== end) {
-					var other = inter._segment,
-						path = other && other._path;
-					if (path) {
-						var next = other.getNext() || path.getFirstSegment(),
-							nextInter = next._intersection;
-						if (other !== segment && (isStart(other)
-							|| isStart(next)
-							|| next && (isValid(other) && (isValid(next)
-								|| nextInter && isValid(nextInter._segment))))
-						) {
-							crossings.push(other);
-						}
-						if (collectStarts)
-							starts.push(other);
-					}
-					inter = inter._next;
-				}
-			}
-
-			if (inter) {
-				collect(inter);
-				while (inter && inter._previous)
-					inter = inter._previous;
-				collect(inter, start);
-			}
-			return crossings;
-		}
-
-		segments.sort(function(seg1, seg2) {
-			var inter1 = seg1._intersection,
-				inter2 = seg2._intersection,
-				over1 = !!(inter1 && inter1._overlap),
-				over2 = !!(inter2 && inter2._overlap),
-				path1 = seg1._path,
-				path2 = seg2._path;
-			return over1 ^ over2
-					? over1 ? 1 : -1
-					: !inter1 ^ !inter2
-						? inter1 ? 1 : -1
-						: path1 !== path2
-							? path1._id - path2._id
-							: seg1._index - seg2._index;
-		});
-
-		for (var i = 0, l = segments.length; i < l; i++) {
-			var seg = segments[i],
-				valid = isValid(seg),
-				path = null,
-				finished = false,
-				closed = true,
-				branches = [],
-				branch,
-				visited,
-				handleIn;
-			if (valid && seg._path._overlapsOnly) {
-				var path1 = seg._path,
-					path2 = seg._intersection._segment._path;
-				if (path1.compare(path2)) {
-					if (path1.getArea())
-						paths.push(path1.clone(false));
-					visitPath(path1);
-					visitPath(path2);
-					valid = false;
-				}
-			}
-			while (valid) {
-				var first = !path,
-					crossings = getCrossingSegments(seg, first),
-					other = crossings.shift(),
-					finished = !first && (isStart(seg) || isStart(other)),
-					cross = !finished && other;
-				if (first) {
-					path = new Path(Item.NO_INSERT);
-					branch = null;
-				}
-				if (finished) {
-					if (seg.isFirst() || seg.isLast())
-						closed = seg._path._closed;
-					seg._visited = true;
-					break;
-				}
-				if (cross && branch) {
-					branches.push(branch);
-					branch = null;
-				}
-				if (!branch) {
-					if (cross)
-						crossings.push(seg);
-					branch = {
-						start: path._segments.length,
-						crossings: crossings,
-						visited: visited = [],
-						handleIn: handleIn
-					};
-				}
-				if (cross)
-					seg = other;
-				if (!isValid(seg)) {
-					path.removeSegments(branch.start);
-					for (var j = 0, k = visited.length; j < k; j++) {
-						visited[j]._visited = false;
-					}
-					visited.length = 0;
-					do {
-						seg = branch && branch.crossings.shift();
-						if (!seg || !seg._path) {
-							seg = null;
-							branch = branches.pop();
-							if (branch) {
-								visited = branch.visited;
-								handleIn = branch.handleIn;
-							}
-						}
-					} while (branch && !isValid(seg));
-					if (!seg)
-						break;
-				}
-				var next = seg.getNext();
-				path.add(new Segment(seg._point, handleIn,
-						next && seg._handleOut));
-				seg._visited = true;
-				visited.push(seg);
-				seg = next || seg._path.getFirstSegment();
-				handleIn = next && next._handleIn;
-			}
-			if (finished) {
-				if (closed) {
-					path.getFirstSegment().setHandleIn(handleIn);
-					path.setClosed(closed);
-				}
-				if (path.getArea() !== 0) {
-					paths.push(path);
-				}
-			}
-		}
-		return paths;
-	}
-
-	return {
-		_getWinding: function(point, dir, closed) {
-			return getWinding(point, this.getCurves(), dir, closed);
-		},
-
-		unite: function(path, options) {
-			return traceBoolean(this, path, 'unite', options);
-		},
-
-		intersect: function(path, options) {
-			return traceBoolean(this, path, 'intersect', options);
-		},
-
-		subtract: function(path, options) {
-			return traceBoolean(this, path, 'subtract', options);
-		},
-
-		exclude: function(path, options) {
-			return traceBoolean(this, path, 'exclude', options);
-		},
-
-		divide: function(path, options) {
-			return options && (options.trace == false || options.stroke)
-					? splitBoolean(this, path, 'divide')
-					: createResult([
-						this.subtract(path, options),
-						this.intersect(path, options)
-					], true, this, path, options);
-		},
-
-		resolveCrossings: function() {
-			var children = this._children,
-				paths = children || [this];
-
-			function hasOverlap(seg, path) {
-				var inter = seg && seg._intersection;
-				return inter && inter._overlap && inter._path === path;
-			}
-
-			var hasOverlaps = false,
-				hasCrossings = false,
-				intersections = this.getIntersections(null, function(inter) {
-					return inter.hasOverlap() && (hasOverlaps = true) ||
-							inter.isCrossing() && (hasCrossings = true);
-				}),
-				clearCurves = hasOverlaps && hasCrossings && [];
-			intersections = CurveLocation.expand(intersections);
-			if (hasOverlaps) {
-				var overlaps = divideLocations(intersections, function(inter) {
-					return inter.hasOverlap();
-				}, clearCurves);
-				for (var i = overlaps.length - 1; i >= 0; i--) {
-					var overlap = overlaps[i],
-						path = overlap._path,
-						seg = overlap._segment,
-						prev = seg.getPrevious(),
-						next = seg.getNext();
-					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
-						seg.remove();
-						prev._handleOut._set(0, 0);
-						next._handleIn._set(0, 0);
-						if (prev !== seg && !prev.getCurve().hasLength()) {
-							next._handleIn.set(prev._handleIn);
-							prev.remove();
-						}
-					}
-				}
-			}
-			if (hasCrossings) {
-				divideLocations(intersections, hasOverlaps && function(inter) {
-					var curve1 = inter.getCurve(),
-						seg1 = inter.getSegment(),
-						other = inter._intersection,
-						curve2 = other._curve,
-						seg2 = other._segment;
-					if (curve1 && curve2 && curve1._path && curve2._path)
-						return true;
-					if (seg1)
-						seg1._intersection = null;
-					if (seg2)
-						seg2._intersection = null;
-				}, clearCurves);
-				if (clearCurves)
-					clearCurveHandles(clearCurves);
-				paths = tracePaths(Base.each(paths, function(path) {
-					Base.push(this, path._segments);
-				}, []));
-			}
-			var length = paths.length,
-				item;
-			if (length > 1 && children) {
-				if (paths !== children)
-					this.setChildren(paths);
-				item = this;
-			} else if (length === 1 && !children) {
-				if (paths[0] !== this)
-					this.setSegments(paths[0].removeSegments());
-				item = this;
-			}
-			if (!item) {
-				item = new CompoundPath(Item.NO_INSERT);
-				item.addChildren(paths);
-				item = item.reduce();
-				item.copyAttributes(this);
-				this.replaceWith(item);
-			}
-			return item;
-		},
-
-		reorient: function(nonZero, clockwise) {
-			var children = this._children;
-			if (children && children.length) {
-				this.setChildren(reorientPaths(this.removeChildren(),
-						function(w) {
-							return !!(nonZero ? w : w & 1);
-						},
-						clockwise));
-			} else if (clockwise !== undefined) {
-				this.setClockwise(clockwise);
-			}
-			return this;
-		},
-
-		getInteriorPoint: function() {
-			var bounds = this.getBounds(),
-				point = bounds.getCenter(true);
-			if (!this.contains(point)) {
-				var curves = this.getCurves(),
-					y = point.y,
-					intercepts = [],
-					roots = [];
-				for (var i = 0, l = curves.length; i < l; i++) {
-					var v = curves[i].getValues(),
-						o0 = v[1],
-						o1 = v[3],
-						o2 = v[5],
-						o3 = v[7];
-					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
-						var monoCurves = Curve.getMonoCurves(v);
-						for (var j = 0, m = monoCurves.length; j < m; j++) {
-							var mv = monoCurves[j],
-								mo0 = mv[1],
-								mo3 = mv[7];
-							if ((mo0 !== mo3) &&
-								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
-								var x = y === mo0 ? mv[0]
-									: y === mo3 ? mv[6]
-									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
-										=== 1
-										? Curve.getPoint(mv, roots[0]).x
-										: (mv[0] + mv[6]) / 2;
-								intercepts.push(x);
-							}
-						}
-					}
-				}
-				if (intercepts.length > 1) {
-					intercepts.sort(function(a, b) { return a - b; });
-					point.x = (intercepts[0] + intercepts[1]) / 2;
-				}
-			}
-			return point;
-		}
-	};
-});
-
-var PathFlattener = Base.extend({
-	_class: 'PathFlattener',
-
-	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
-		var curves = [],
-			parts = [],
-			length = 0,
-			minSpan = 1 / (maxRecursion || 32),
-			segments = path._segments,
-			segment1 = segments[0],
-			segment2;
-
-		function addCurve(segment1, segment2) {
-			var curve = Curve.getValues(segment1, segment2, matrix);
-			curves.push(curve);
-			computeParts(curve, segment1._index, 0, 1);
-		}
-
-		function computeParts(curve, index, t1, t2) {
-			if ((t2 - t1) > minSpan
-					&& !(ignoreStraight && Curve.isStraight(curve))
-					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
-				var halves = Curve.subdivide(curve, 0.5),
-					tMid = (t1 + t2) / 2;
-				computeParts(halves[0], index, t1, tMid);
-				computeParts(halves[1], index, tMid, t2);
-			} else {
-				var dx = curve[6] - curve[0],
-					dy = curve[7] - curve[1],
-					dist = Math.sqrt(dx * dx + dy * dy);
-				if (dist > 0) {
-					length += dist;
-					parts.push({
-						offset: length,
-						curve: curve,
-						index: index,
-						time: t2,
-					});
-				}
-			}
-		}
-
-		for (var i = 1, l = segments.length; i < l; i++) {
-			segment2 = segments[i];
-			addCurve(segment1, segment2);
-			segment1 = segment2;
-		}
-		if (path._closed)
-			addCurve(segment2 || segment1, segments[0]);
-		this.curves = curves;
-		this.parts = parts;
-		this.length = length;
-		this.index = 0;
-	},
-
-	_get: function(offset) {
-		var parts = this.parts,
-			length = parts.length,
-			start,
-			i, j = this.index;
-		for (;;) {
-			i = j;
-			if (!j || parts[--j].offset < offset)
-				break;
-		}
-		for (; i < length; i++) {
-			var part = parts[i];
-			if (part.offset >= offset) {
-				this.index = i;
-				var prev = parts[i - 1],
-					prevTime = prev && prev.index === part.index ? prev.time : 0,
-					prevOffset = prev ? prev.offset : 0;
-				return {
-					index: part.index,
-					time: prevTime + (part.time - prevTime)
-						* (offset - prevOffset) / (part.offset - prevOffset)
-				};
-			}
-		}
-		return {
-			index: parts[length - 1].index,
-			time: 1
-		};
-	},
-
-	drawPart: function(ctx, from, to) {
-		var start = this._get(from),
-			end = this._get(to);
-		for (var i = start.index, l = end.index; i <= l; i++) {
-			var curve = Curve.getPart(this.curves[i],
-					i === start.index ? start.time : 0,
-					i === end.index ? end.time : 1);
-			if (i === start.index)
-				ctx.moveTo(curve[0], curve[1]);
-			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
-		}
-	}
-}, Base.each(Curve._evaluateMethods,
-	function(name) {
-		this[name + 'At'] = function(offset) {
-			var param = this._get(offset);
-			return Curve[name](this.curves[param.index], param.time);
-		};
-	}, {})
-);
-
-var PathFitter = Base.extend({
-	initialize: function(path) {
-		var points = this.points = [],
-			segments = path._segments,
-			closed = path._closed;
-		for (var i = 0, prev, l = segments.length; i < l; i++) {
-			var point = segments[i].point;
-			if (!prev || !prev.equals(point)) {
-				points.push(prev = point.clone());
-			}
-		}
-		if (closed) {
-			points.unshift(points[points.length - 1]);
-			points.push(points[1]);
-		}
-		this.closed = closed;
-	},
-
-	fit: function(error) {
-		var points = this.points,
-			length = points.length,
-			segments = null;
-		if (length > 0) {
-			segments = [new Segment(points[0])];
-			if (length > 1) {
-				this.fitCubic(segments, error, 0, length - 1,
-						points[1].subtract(points[0]),
-						points[length - 2].subtract(points[length - 1]));
-				if (this.closed) {
-					segments.shift();
-					segments.pop();
-				}
-			}
-		}
-		return segments;
-	},
-
-	fitCubic: function(segments, error, first, last, tan1, tan2) {
-		var points = this.points;
-		if (last - first === 1) {
-			var pt1 = points[first],
-				pt2 = points[last],
-				dist = pt1.getDistance(pt2) / 3;
-			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
-					pt2.add(tan2.normalize(dist)), pt2]);
-			return;
-		}
-		var uPrime = this.chordLengthParameterize(first, last),
-			maxError = Math.max(error, error * error),
-			split,
-			parametersInOrder = true;
-		for (var i = 0; i <= 4; i++) {
-			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
-			var max = this.findMaxError(first, last, curve, uPrime);
-			if (max.error < error && parametersInOrder) {
-				this.addCurve(segments, curve);
-				return;
-			}
-			split = max.index;
-			if (max.error >= maxError)
-				break;
-			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
-			maxError = max.error;
-		}
-		var tanCenter = points[split - 1].subtract(points[split + 1]);
-		this.fitCubic(segments, error, first, split, tan1, tanCenter);
-		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
-	},
-
-	addCurve: function(segments, curve) {
-		var prev = segments[segments.length - 1];
-		prev.setHandleOut(curve[1].subtract(curve[0]));
-		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
-	},
-
-	generateBezier: function(first, last, uPrime, tan1, tan2) {
-		var epsilon = 1e-12,
-			abs = Math.abs,
-			points = this.points,
-			pt1 = points[first],
-			pt2 = points[last],
-			C = [[0, 0], [0, 0]],
-			X = [0, 0];
-
-		for (var i = 0, l = last - first + 1; i < l; i++) {
-			var u = uPrime[i],
-				t = 1 - u,
-				b = 3 * u * t,
-				b0 = t * t * t,
-				b1 = b * t,
-				b2 = b * u,
-				b3 = u * u * u,
-				a1 = tan1.normalize(b1),
-				a2 = tan2.normalize(b2),
-				tmp = points[first + i]
-					.subtract(pt1.multiply(b0 + b1))
-					.subtract(pt2.multiply(b2 + b3));
-			C[0][0] += a1.dot(a1);
-			C[0][1] += a1.dot(a2);
-			C[1][0] = C[0][1];
-			C[1][1] += a2.dot(a2);
-			X[0] += a1.dot(tmp);
-			X[1] += a2.dot(tmp);
-		}
-
-		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
-			alpha1,
-			alpha2;
-		if (abs(detC0C1) > epsilon) {
-			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
-				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
-			alpha1 = detXC1 / detC0C1;
-			alpha2 = detC0X / detC0C1;
-		} else {
-			var c0 = C[0][0] + C[0][1],
-				c1 = C[1][0] + C[1][1];
-			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
-							: abs(c1) > epsilon ? X[1] / c1
-							: 0;
-		}
-
-		var segLength = pt2.getDistance(pt1),
-			eps = epsilon * segLength,
-			handle1,
-			handle2;
-		if (alpha1 < eps || alpha2 < eps) {
-			alpha1 = alpha2 = segLength / 3;
-		} else {
-			var line = pt2.subtract(pt1);
-			handle1 = tan1.normalize(alpha1);
-			handle2 = tan2.normalize(alpha2);
-			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
-				alpha1 = alpha2 = segLength / 3;
-				handle1 = handle2 = null;
-			}
-		}
-
-		return [pt1,
-				pt1.add(handle1 || tan1.normalize(alpha1)),
-				pt2.add(handle2 || tan2.normalize(alpha2)),
-				pt2];
-	},
-
-	reparameterize: function(first, last, u, curve) {
-		for (var i = first; i <= last; i++) {
-			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
-		}
-		for (var i = 1, l = u.length; i < l; i++) {
-			if (u[i] <= u[i - 1])
-				return false;
-		}
-		return true;
-	},
-
-	findRoot: function(curve, point, u) {
-		var curve1 = [],
-			curve2 = [];
-		for (var i = 0; i <= 2; i++) {
-			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
-		}
-		for (var i = 0; i <= 1; i++) {
-			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
-		}
-		var pt = this.evaluate(3, curve, u),
-			pt1 = this.evaluate(2, curve1, u),
-			pt2 = this.evaluate(1, curve2, u),
-			diff = pt.subtract(point),
-			df = pt1.dot(pt1) + diff.dot(pt2);
-		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
-	},
-
-	evaluate: function(degree, curve, t) {
-		var tmp = curve.slice();
-		for (var i = 1; i <= degree; i++) {
-			for (var j = 0; j <= degree - i; j++) {
-				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
-			}
-		}
-		return tmp[0];
-	},
-
-	chordLengthParameterize: function(first, last) {
-		var u = [0];
-		for (var i = first + 1; i <= last; i++) {
-			u[i - first] = u[i - first - 1]
-					+ this.points[i].getDistance(this.points[i - 1]);
-		}
-		for (var i = 1, m = last - first; i <= m; i++) {
-			u[i] /= u[m];
-		}
-		return u;
-	},
-
-	findMaxError: function(first, last, curve, u) {
-		var index = Math.floor((last - first + 1) / 2),
-			maxDist = 0;
-		for (var i = first + 1; i < last; i++) {
-			var P = this.evaluate(3, curve, u[i - first]);
-			var v = P.subtract(this.points[i]);
-			var dist = v.x * v.x + v.y * v.y;
-			if (dist >= maxDist) {
-				maxDist = dist;
-				index = i;
-			}
-		}
-		return {
-			error: maxDist,
-			index: index
-		};
-	}
-});
-
-var TextItem = Item.extend({
-	_class: 'TextItem',
-	_applyMatrix: false,
-	_canApplyMatrix: false,
-	_serializeFields: {
-		content: null
-	},
-	_boundsOptions: { stroke: false, handle: false },
-
-	initialize: function TextItem(arg) {
-		this._content = '';
-		this._lines = [];
-		var hasProps = arg && Base.isPlainObject(arg)
-				&& arg.x === undefined && arg.y === undefined;
-		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
-	},
-
-	_equals: function(item) {
-		return this._content === item._content;
-	},
-
-	copyContent: function(source) {
-		this.setContent(source._content);
-	},
-
-	getContent: function() {
-		return this._content;
-	},
-
-	setContent: function(content) {
-		this._content = '' + content;
-		this._lines = this._content.split(/\r\n|\n|\r/mg);
-		this._changed(521);
-	},
-
-	isEmpty: function() {
-		return !this._content;
-	},
-
-	getCharacterStyle: '#getStyle',
-	setCharacterStyle: '#setStyle',
-
-	getParagraphStyle: '#getStyle',
-	setParagraphStyle: '#setStyle'
-});
-
-var PointText = TextItem.extend({
-	_class: 'PointText',
-
-	initialize: function PointText() {
-		TextItem.apply(this, arguments);
-	},
-
-	getPoint: function() {
-		var point = this._matrix.getTranslation();
-		return new LinkedPoint(point.x, point.y, this, 'setPoint');
-	},
-
-	setPoint: function() {
-		var point = Point.read(arguments);
-		this.translate(point.subtract(this._matrix.getTranslation()));
-	},
-
-	_draw: function(ctx, param, viewMatrix) {
-		if (!this._content)
-			return;
-		this._setStyles(ctx, param, viewMatrix);
-		var lines = this._lines,
-			style = this._style,
-			hasFill = style.hasFill(),
-			hasStroke = style.hasStroke(),
-			leading = style.getLeading(),
-			shadowColor = ctx.shadowColor;
-		ctx.font = style.getFontStyle();
-		ctx.textAlign = style.getJustification();
-		for (var i = 0, l = lines.length; i < l; i++) {
-			ctx.shadowColor = shadowColor;
-			var line = lines[i];
-			if (hasFill) {
-				ctx.fillText(line, 0, 0);
-				ctx.shadowColor = 'rgba(0,0,0,0)';
-			}
-			if (hasStroke)
-				ctx.strokeText(line, 0, 0);
-			ctx.translate(0, leading);
-		}
-	},
-
-	_getBounds: function(matrix, options) {
-		var style = this._style,
-			lines = this._lines,
-			numLines = lines.length,
-			justification = style.getJustification(),
-			leading = style.getLeading(),
-			width = this.getView().getTextWidth(style.getFontStyle(), lines),
-			x = 0;
-		if (justification !== 'left')
-			x -= width / (justification === 'center' ? 2: 1);
-		var rect = new Rectangle(x,
-					numLines ? - 0.75 * leading : 0,
-					width, numLines * leading);
-		return matrix ? matrix._transformBounds(rect, rect) : rect;
-	}
-});
-
-var Color = Base.extend(new function() {
-	var types = {
-		gray: ['gray'],
-		rgb: ['red', 'green', 'blue'],
-		hsb: ['hue', 'saturation', 'brightness'],
-		hsl: ['hue', 'saturation', 'lightness'],
-		gradient: ['gradient', 'origin', 'destination', 'highlight']
-	};
-
-	var componentParsers = {},
-		namedColors = {
-			transparent: [0, 0, 0, 0]
-		},
-		colorCtx;
-
-	function fromCSS(string) {
-		var match = string.match(
-				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
-			) || string.match(
-				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
-			),
-			type = 'rgb',
-			components;
-		if (match) {
-			var amount = match[4] ? 4 : 3;
-			components = new Array(amount);
-			for (var i = 0; i < amount; i++) {
-				var value = match[i + 1];
-				components[i] = parseInt(value.length == 1
-						? value + value : value, 16) / 255;
-			}
-		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
-			type = match[1];
-			components = match[2].trim().split(/[,\s]+/g);
-			var isHSL = type === 'hsl';
-			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
-				var component = components[i];
-				var value = parseFloat(component);
-				if (isHSL) {
-					if (i === 0) {
-						var unit = component.match(/([a-z]*)$/)[1];
-						value *= ({
-							turn: 360,
-							rad: 180 / Math.PI,
-							grad: 0.9
-						}[unit] || 1);
-					} else if (i < 3) {
-						value /= 100;
-					}
-				} else if (i < 3) {
-					value /= /%$/.test(component) ? 100 : 255;
-				}
-				components[i] = value;
-			}
-		} else {
-			var color = namedColors[string];
-			if (!color) {
-				if (window) {
-					if (!colorCtx) {
-						colorCtx = CanvasProvider.getContext(1, 1);
-						colorCtx.globalCompositeOperation = 'copy';
-					}
-					colorCtx.fillStyle = 'rgba(0,0,0,0)';
-					colorCtx.fillStyle = string;
-					colorCtx.fillRect(0, 0, 1, 1);
-					var data = colorCtx.getImageData(0, 0, 1, 1).data;
-					color = namedColors[string] = [
-						data[0] / 255,
-						data[1] / 255,
-						data[2] / 255
-					];
-				} else {
-					color = [0, 0, 0];
-				}
-			}
-			components = color.slice();
-		}
-		return [type, components];
-	}
-
-	var hsbIndices = [
-		[0, 3, 1],
-		[2, 0, 1],
-		[1, 0, 3],
-		[1, 2, 0],
-		[3, 1, 0],
-		[0, 1, 2]
-	];
-
-	var converters = {
-		'rgb-hsb': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				h = delta === 0 ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60;
-			return [h, max === 0 ? 0 : delta / max, max];
-		},
-
-		'hsb-rgb': function(h, s, b) {
-			h = (((h / 60) % 6) + 6) % 6;
-			var i = Math.floor(h),
-				f = h - i,
-				i = hsbIndices[i],
-				v = [
-					b,
-					b * (1 - s),
-					b * (1 - s * f),
-					b * (1 - s * (1 - f))
-				];
-			return [v[i[0]], v[i[1]], v[i[2]]];
-		},
-
-		'rgb-hsl': function(r, g, b) {
-			var max = Math.max(r, g, b),
-				min = Math.min(r, g, b),
-				delta = max - min,
-				achromatic = delta === 0,
-				h = achromatic ? 0
-					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
-						: max == g ? (b - r) / delta + 2
-						:            (r - g) / delta + 4) * 60,
-				l = (max + min) / 2,
-				s = achromatic ? 0 : l < 0.5
-						? delta / (max + min)
-						: delta / (2 - max - min);
-			return [h, s, l];
-		},
-
-		'hsl-rgb': function(h, s, l) {
-			h = (((h / 360) % 1) + 1) % 1;
-			if (s === 0)
-				return [l, l, l];
-			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
-				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
-				t1 = 2 * l - t2,
-				c = [];
-			for (var i = 0; i < 3; i++) {
-				var t3 = t3s[i];
-				if (t3 < 0) t3 += 1;
-				if (t3 > 1) t3 -= 1;
-				c[i] = 6 * t3 < 1
-					? t1 + (t2 - t1) * 6 * t3
-					: 2 * t3 < 1
-						? t2
-						: 3 * t3 < 2
-							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
-							: t1;
-			}
-			return c;
-		},
-
-		'rgb-gray': function(r, g, b) {
-			return [r * 0.2989 + g * 0.587 + b * 0.114];
-		},
-
-		'gray-rgb': function(g) {
-			return [g, g, g];
-		},
-
-		'gray-hsb': function(g) {
-			return [0, 0, g];
-		},
-
-		'gray-hsl': function(g) {
-			return [0, 0, g];
-		},
-
-		'gradient-rgb': function() {
-			return [];
-		},
-
-		'rgb-gradient': function() {
-			return [];
-		}
-
-	};
-
-	return Base.each(types, function(properties, type) {
-		componentParsers[type] = [];
-		Base.each(properties, function(name, index) {
-			var part = Base.capitalize(name),
-				hasOverlap = /^(hue|saturation)$/.test(name),
-				parser = componentParsers[type][index] = type === 'gradient'
-					? name === 'gradient'
-						? function(value) {
-							var current = this._components[0];
-							value = Gradient.read(
-								Array.isArray(value)
-									? value
-									: arguments, 0, { readNull: true }
-							);
-							if (current !== value) {
-								if (current)
-									current._removeOwner(this);
-								if (value)
-									value._addOwner(this);
-							}
-							return value;
-						}
-						: function() {
-							return Point.read(arguments, 0, {
-									readNull: name === 'highlight',
-									clone: true
-							});
-						}
-					: function(value) {
-						return value == null || isNaN(value) ? 0 : +value;
-					};
-			this['get' + part] = function() {
-				return this._type === type
-					|| hasOverlap && /^hs[bl]$/.test(this._type)
-						? this._components[index]
-						: this._convert(type)[index];
-			};
-
-			this['set' + part] = function(value) {
-				if (this._type !== type
-						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
-					this._components = this._convert(type);
-					this._properties = types[type];
-					this._type = type;
-				}
-				this._components[index] = parser.call(this, value);
-				this._changed();
-			};
-		}, this);
-	}, {
-		_class: 'Color',
-		_readIndex: true,
-
-		initialize: function Color(arg) {
-			var args = arguments,
-				reading = this.__read,
-				read = 0,
-				type,
-				components,
-				alpha,
-				values;
-			if (Array.isArray(arg)) {
-				args = arg;
-				arg = args[0];
-			}
-			var argType = arg != null && typeof arg;
-			if (argType === 'string' && arg in types) {
-				type = arg;
-				arg = args[1];
-				if (Array.isArray(arg)) {
-					components = arg;
-					alpha = args[2];
-				} else {
-					if (reading)
-						read = 1;
-					args = Base.slice(args, 1);
-					argType = typeof arg;
-				}
-			}
-			if (!components) {
-				values = argType === 'number'
-						? args
-						: argType === 'object' && arg.length != null
-							? arg
-							: null;
-				if (values) {
-					if (!type)
-						type = values.length >= 3
-								? 'rgb'
-								: 'gray';
-					var length = types[type].length;
-					alpha = values[length];
-					if (reading) {
-						read += values === arguments
-							? length + (alpha != null ? 1 : 0)
-							: 1;
-					}
-					if (values.length > length)
-						values = Base.slice(values, 0, length);
-				} else if (argType === 'string') {
-					var converted = fromCSS(arg);
-					type = converted[0];
-					components = converted[1];
-					if (components.length === 4) {
-						alpha = components[3];
-						components.length--;
-					}
-				} else if (argType === 'object') {
-					if (arg.constructor === Color) {
-						type = arg._type;
-						components = arg._components.slice();
-						alpha = arg._alpha;
-						if (type === 'gradient') {
-							for (var i = 1, l = components.length; i < l; i++) {
-								var point = components[i];
-								if (point)
-									components[i] = point.clone();
-							}
-						}
-					} else if (arg.constructor === Gradient) {
-						type = 'gradient';
-						values = args;
-					} else {
-						type = 'hue' in arg
-							? 'lightness' in arg
-								? 'hsl'
-								: 'hsb'
-							: 'gradient' in arg || 'stops' in arg
-									|| 'radial' in arg
-								? 'gradient'
-								: 'gray' in arg
-									? 'gray'
-									: 'rgb';
-						var properties = types[type],
-							parsers = componentParsers[type];
-						this._components = components = [];
-						for (var i = 0, l = properties.length; i < l; i++) {
-							var value = arg[properties[i]];
-							if (value == null && !i && type === 'gradient'
-									&& 'stops' in arg) {
-								value = {
-									stops: arg.stops,
-									radial: arg.radial
-								};
-							}
-							value = parsers[i].call(this, value);
-							if (value != null)
-								components[i] = value;
-						}
-						alpha = arg.alpha;
-					}
-				}
-				if (reading && type)
-					read = 1;
-			}
-			this._type = type || 'rgb';
-			if (!components) {
-				this._components = components = [];
-				var parsers = componentParsers[this._type];
-				for (var i = 0, l = parsers.length; i < l; i++) {
-					var value = parsers[i].call(this, values && values[i]);
-					if (value != null)
-						components[i] = value;
-				}
-			}
-			this._components = components;
-			this._properties = types[this._type];
-			this._alpha = alpha;
-			if (reading)
-				this.__read = read;
-			return this;
-		},
-
-		set: '#initialize',
-
-		_serialize: function(options, dictionary) {
-			var components = this.getComponents();
-			return Base.serialize(
-					/^(gray|rgb)$/.test(this._type)
-						? components
-						: [this._type].concat(components),
-					options, true, dictionary);
-		},
-
-		_changed: function() {
-			this._canvasStyle = null;
-			if (this._owner) {
-				if (this._setter) {
-					this._owner[this._setter](this);
-				} else {
-					this._owner._changed(129);
-				}
-			}
-		},
-
-		_convert: function(type) {
-			var converter;
-			return this._type === type
-					? this._components.slice()
-					: (converter = converters[this._type + '-' + type])
-						? converter.apply(this, this._components)
-						: converters['rgb-' + type].apply(this,
-							converters[this._type + '-rgb'].apply(this,
-								this._components));
-		},
-
-		convert: function(type) {
-			return new Color(type, this._convert(type), this._alpha);
-		},
-
-		getType: function() {
-			return this._type;
-		},
-
-		setType: function(type) {
-			this._components = this._convert(type);
-			this._properties = types[type];
-			this._type = type;
-		},
-
-		getComponents: function() {
-			var components = this._components.slice();
-			if (this._alpha != null)
-				components.push(this._alpha);
-			return components;
-		},
-
-		getAlpha: function() {
-			return this._alpha != null ? this._alpha : 1;
-		},
-
-		setAlpha: function(alpha) {
-			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
-			this._changed();
-		},
-
-		hasAlpha: function() {
-			return this._alpha != null;
-		},
-
-		equals: function(color) {
-			var col = Base.isPlainValue(color, true)
-					? Color.read(arguments)
-					: color;
-			return col === this || col && this._class === col._class
-					&& this._type === col._type
-					&& this.getAlpha() === col.getAlpha()
-					&& Base.equals(this._components, col._components)
-					|| false;
-		},
-
-		toString: function() {
-			var properties = this._properties,
-				parts = [],
-				isGradient = this._type === 'gradient',
-				f = Formatter.instance;
-			for (var i = 0, l = properties.length; i < l; i++) {
-				var value = this._components[i];
-				if (value != null)
-					parts.push(properties[i] + ': '
-							+ (isGradient ? value : f.number(value)));
-			}
-			if (this._alpha != null)
-				parts.push('alpha: ' + f.number(this._alpha));
-			return '{ ' + parts.join(', ') + ' }';
-		},
-
-		toCSS: function(hex) {
-			var components = this._convert('rgb'),
-				alpha = hex || this._alpha == null ? 1 : this._alpha;
-			function convert(val) {
-				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
-			}
-			components = [
-				convert(components[0]),
-				convert(components[1]),
-				convert(components[2])
-			];
-			if (alpha < 1)
-				components.push(alpha < 0 ? 0 : alpha);
-			return hex
-					? '#' + ((1 << 24) + (components[0] << 16)
-						+ (components[1] << 8)
-						+ components[2]).toString(16).slice(1)
-					: (components.length == 4 ? 'rgba(' : 'rgb(')
-						+ components.join(',') + ')';
-		},
-
-		toCanvasStyle: function(ctx, matrix) {
-			if (this._canvasStyle)
-				return this._canvasStyle;
-			if (this._type !== 'gradient')
-				return this._canvasStyle = this.toCSS();
-			var components = this._components,
-				gradient = components[0],
-				stops = gradient._stops,
-				origin = components[1],
-				destination = components[2],
-				highlight = components[3],
-				inverse = matrix && matrix.inverted(),
-				canvasGradient;
-			if (inverse) {
-				origin = inverse._transformPoint(origin);
-				destination = inverse._transformPoint(destination);
-				if (highlight)
-					highlight = inverse._transformPoint(highlight);
-			}
-			if (gradient._radial) {
-				var radius = destination.getDistance(origin);
-				if (highlight) {
-					var vector = highlight.subtract(origin);
-					if (vector.getLength() > radius)
-						highlight = origin.add(vector.normalize(radius - 0.1));
-				}
-				var start = highlight || origin;
-				canvasGradient = ctx.createRadialGradient(start.x, start.y,
-						0, origin.x, origin.y, radius);
-			} else {
-				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
-						destination.x, destination.y);
-			}
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					offset = stop._offset;
-				canvasGradient.addColorStop(
-						offset == null ? i / (l - 1) : offset,
-						stop._color.toCanvasStyle());
-			}
-			return this._canvasStyle = canvasGradient;
-		},
-
-		transform: function(matrix) {
-			if (this._type === 'gradient') {
-				var components = this._components;
-				for (var i = 1, l = components.length; i < l; i++) {
-					var point = components[i];
-					matrix._transformPoint(point, point, true);
-				}
-				this._changed();
-			}
-		},
-
-		statics: {
-			_types: types,
-
-			random: function() {
-				var random = Math.random;
-				return new Color(random(), random(), random());
-			},
-
-			_setOwner: function(color, owner, setter) {
-				if (color) {
-					if (color._owner && owner && color._owner !== owner) {
-						color = color.clone();
-					}
-					if (!color._owner ^ !owner) {
-						color._owner = owner || null;
-						color._setter = setter || null;
-					}
-				}
-				return color;
-			}
-		}
-	});
-},
-new function() {
-	var operators = {
-		add: function(a, b) {
-			return a + b;
-		},
-
-		subtract: function(a, b) {
-			return a - b;
-		},
-
-		multiply: function(a, b) {
-			return a * b;
-		},
-
-		divide: function(a, b) {
-			return a / b;
-		}
-	};
-
-	return Base.each(operators, function(operator, name) {
-		this[name] = function(color) {
-			color = Color.read(arguments);
-			var type = this._type,
-				components1 = this._components,
-				components2 = color._convert(type);
-			for (var i = 0, l = components1.length; i < l; i++)
-				components2[i] = operator(components1[i], components2[i]);
-			return new Color(type, components2,
-					this._alpha != null
-							? operator(this._alpha, color.getAlpha())
-							: null);
-		};
-	}, {
-	});
-});
-
-var Gradient = Base.extend({
-	_class: 'Gradient',
-
-	initialize: function Gradient(stops, radial) {
-		this._id = UID.get();
-		if (stops && Base.isPlainObject(stops)) {
-			this.set(stops);
-			stops = radial = null;
-		}
-		if (this._stops == null) {
-			this.setStops(stops || ['white', 'black']);
-		}
-		if (this._radial == null) {
-			this.setRadial(typeof radial === 'string' && radial === 'radial'
-					|| radial || false);
-		}
-	},
-
-	_serialize: function(options, dictionary) {
-		return dictionary.add(this, function() {
-			return Base.serialize([this._stops, this._radial],
-					options, true, dictionary);
-		});
-	},
-
-	_changed: function() {
-		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
-			this._owners[i]._changed();
-		}
-	},
-
-	_addOwner: function(color) {
-		if (!this._owners)
-			this._owners = [];
-		this._owners.push(color);
-	},
-
-	_removeOwner: function(color) {
-		var index = this._owners ? this._owners.indexOf(color) : -1;
-		if (index != -1) {
-			this._owners.splice(index, 1);
-			if (!this._owners.length)
-				this._owners = undefined;
-		}
-	},
-
-	clone: function() {
-		var stops = [];
-		for (var i = 0, l = this._stops.length; i < l; i++) {
-			stops[i] = this._stops[i].clone();
-		}
-		return new Gradient(stops, this._radial);
-	},
-
-	getStops: function() {
-		return this._stops;
-	},
-
-	setStops: function(stops) {
-		if (stops.length < 2) {
-			throw new Error(
-					'Gradient stop list needs to contain at least two stops.');
-		}
-		var _stops = this._stops;
-		if (_stops) {
-			for (var i = 0, l = _stops.length; i < l; i++)
-				_stops[i]._owner = undefined;
-		}
-		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
-		for (var i = 0, l = _stops.length; i < l; i++)
-			_stops[i]._owner = this;
-		this._changed();
-	},
-
-	getRadial: function() {
-		return this._radial;
-	},
-
-	setRadial: function(radial) {
-		this._radial = radial;
-		this._changed();
-	},
-
-	equals: function(gradient) {
-		if (gradient === this)
-			return true;
-		if (gradient && this._class === gradient._class) {
-			var stops1 = this._stops,
-				stops2 = gradient._stops,
-				length = stops1.length;
-			if (length === stops2.length) {
-				for (var i = 0; i < length; i++) {
-					if (!stops1[i].equals(stops2[i]))
-						return false;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-});
-
-var GradientStop = Base.extend({
-	_class: 'GradientStop',
-
-	initialize: function GradientStop(arg0, arg1) {
-		var color = arg0,
-			offset = arg1;
-		if (typeof arg0 === 'object' && arg1 === undefined) {
-			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
-				color = arg0[0];
-				offset = arg0[1];
-			} else if ('color' in arg0 || 'offset' in arg0
-					|| 'rampPoint' in arg0) {
-				color = arg0.color;
-				offset = arg0.offset || arg0.rampPoint || 0;
-			}
-		}
-		this.setColor(color);
-		this.setOffset(offset);
-	},
-
-	clone: function() {
-		return new GradientStop(this._color.clone(), this._offset);
-	},
-
-	_serialize: function(options, dictionary) {
-		var color = this._color,
-			offset = this._offset;
-		return Base.serialize(offset == null ? [color] : [color, offset],
-				options, true, dictionary);
-	},
-
-	_changed: function() {
-		if (this._owner)
-			this._owner._changed(129);
-	},
-
-	getOffset: function() {
-		return this._offset;
-	},
-
-	setOffset: function(offset) {
-		this._offset = offset;
-		this._changed();
-	},
-
-	getRampPoint: '#getOffset',
-	setRampPoint: '#setOffset',
-
-	getColor: function() {
-		return this._color;
-	},
-
-	setColor: function() {
-		Color._setOwner(this._color, null);
-		this._color = Color._setOwner(Color.read(arguments, 0), this,
-				'setColor');
-		this._changed();
-	},
-
-	equals: function(stop) {
-		return stop === this || stop && this._class === stop._class
-				&& this._color.equals(stop._color)
-				&& this._offset == stop._offset
-				|| false;
-	}
-});
-
-var Style = Base.extend(new function() {
-	var itemDefaults = {
-		fillColor: null,
-		fillRule: 'nonzero',
-		strokeColor: null,
-		strokeWidth: 1,
-		strokeCap: 'butt',
-		strokeJoin: 'miter',
-		strokeScaling: true,
-		miterLimit: 10,
-		dashOffset: 0,
-		dashArray: [],
-		shadowColor: null,
-		shadowBlur: 0,
-		shadowOffset: new Point(),
-		selectedColor: null
-	},
-	groupDefaults = Base.set({}, itemDefaults, {
-		fontFamily: 'sans-serif',
-		fontWeight: 'normal',
-		fontSize: 12,
-		leading: null,
-		justification: 'left'
-	}),
-	textDefaults = Base.set({}, groupDefaults, {
-		fillColor: new Color()
-	}),
-	flags = {
-		strokeWidth: 193,
-		strokeCap: 193,
-		strokeJoin: 193,
-		strokeScaling: 201,
-		miterLimit: 193,
-		fontFamily: 9,
-		fontWeight: 9,
-		fontSize: 9,
-		font: 9,
-		leading: 9,
-		justification: 9
-	},
-	item = {
-		beans: true
-	},
-	fields = {
-		_class: 'Style',
-		beans: true,
-
-		initialize: function Style(style, _owner, _project) {
-			this._values = {};
-			this._owner = _owner;
-			this._project = _owner && _owner._project || _project
-					|| paper.project;
-			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
-					: _owner instanceof TextItem ? textDefaults
-					: itemDefaults;
-			if (style)
-				this.set(style);
-		}
-	};
-
-	Base.each(groupDefaults, function(value, key) {
-		var isColor = /Color$/.test(key),
-			isPoint = key === 'shadowOffset',
-			part = Base.capitalize(key),
-			flag = flags[key],
-			set = 'set' + part,
-			get = 'get' + part;
-
-		fields[set] = function(value) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath);
-			if (applyToChildren) {
-				for (var i = 0, l = children.length; i < l; i++)
-					children[i]._style[set](value);
-			}
-			if ((key === 'selectedColor' || !applyToChildren)
-					&& key in this._defaults) {
-				var old = this._values[key];
-				if (old !== value) {
-					if (isColor) {
-						if (old) {
-							Color._setOwner(old, null);
-							old._canvasStyle = null;
-						}
-						if (value && value.constructor === Color) {
-							value = Color._setOwner(value, owner,
-									applyToChildren && set);
-						}
-					}
-					this._values[key] = value;
-					if (owner)
-						owner._changed(flag || 129);
-				}
-			}
-		};
-
-		fields[get] = function(_dontMerge) {
-			var owner = this._owner,
-				children = owner && owner._children,
-				applyToChildren = children && children.length > 0
-					&& !(owner instanceof CompoundPath),
-				value;
-			if (applyToChildren && !_dontMerge) {
-				for (var i = 0, l = children.length; i < l; i++) {
-					var childValue = children[i]._style[get]();
-					if (!i) {
-						value = childValue;
-					} else if (!Base.equals(value, childValue)) {
-						return undefined;
-					}
-				}
-			} else if (key in this._defaults) {
-				var value = this._values[key];
-				if (value === undefined) {
-					value = this._defaults[key];
-					if (value && value.clone) {
-						value = value.clone();
-					}
-				} else {
-					var ctor = isColor ? Color : isPoint ? Point : null;
-					if (ctor && !(value && value.constructor === ctor)) {
-						this._values[key] = value = ctor.read([value], 0,
-								{ readNull: true, clone: true });
-					}
-				}
-			}
-			if (value && isColor) {
-				value = Color._setOwner(value, owner, applyToChildren && set);
-			}
-			return value;
-		};
-
-		item[get] = function(_dontMerge) {
-			return this._style[get](_dontMerge);
-		};
-
-		item[set] = function(value) {
-			this._style[set](value);
-		};
-	});
-
-	Base.each({
-		Font: 'FontFamily',
-		WindingRule: 'FillRule'
-	}, function(value, key) {
-		var get = 'get' + key,
-			set = 'set' + key;
-		fields[get] = item[get] = '#get' + value;
-		fields[set] = item[set] = '#set' + value;
-	});
-
-	Item.inject(item);
-	return fields;
-}, {
-	set: function(style) {
-		var isStyle = style instanceof Style,
-			values = isStyle ? style._values : style;
-		if (values) {
-			for (var key in values) {
-				if (key in this._defaults) {
-					var value = values[key];
-					this[key] = value && isStyle && value.clone
-							? value.clone() : value;
-				}
-			}
-		}
-	},
-
-	equals: function(style) {
-		function compare(style1, style2, secondary) {
-			var values1 = style1._values,
-				values2 = style2._values,
-				defaults2 = style2._defaults;
-			for (var key in values1) {
-				var value1 = values1[key],
-					value2 = values2[key];
-				if (!(secondary && key in values2) && !Base.equals(value1,
-						value2 === undefined ? defaults2[key] : value2))
-					return false;
-			}
-			return true;
-		}
-
-		return style === this || style && this._class === style._class
-				&& compare(this, style)
-				&& compare(style, this, true)
-				|| false;
-	},
-
-	_dispose: function() {
-		var color;
-		color = this.getFillColor();
-		if (color) color._canvasStyle = null;
-		color = this.getStrokeColor();
-		if (color) color._canvasStyle = null;
-		color = this.getShadowColor();
-		if (color) color._canvasStyle = null;
-	},
-
-	hasFill: function() {
-		var color = this.getFillColor();
-		return !!color && color.alpha > 0;
-	},
-
-	hasStroke: function() {
-		var color = this.getStrokeColor();
-		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
-	},
-
-	hasShadow: function() {
-		var color = this.getShadowColor();
-		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
-				|| !this.getShadowOffset().isZero());
-	},
-
-	getView: function() {
-		return this._project._view;
-	},
-
-	getFontStyle: function() {
-		var fontSize = this.getFontSize();
-		return this.getFontWeight()
-				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
-				+ this.getFontFamily();
-	},
-
-	getFont: '#getFontFamily',
-	setFont: '#setFontFamily',
-
-	getLeading: function getLeading() {
-		var leading = getLeading.base.call(this),
-			fontSize = this.getFontSize();
-		if (/pt|em|%|px/.test(fontSize))
-			fontSize = this.getView().getPixelSize(fontSize);
-		return leading != null ? leading : fontSize * 1.2;
-	}
-
-});
-
-var DomElement = new function() {
-	function handlePrefix(el, name, set, value) {
-		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
-			suffix = name[0].toUpperCase() + name.substring(1);
-		for (var i = 0; i < 6; i++) {
-			var prefix = prefixes[i],
-				key = prefix ? prefix + suffix : name;
-			if (key in el) {
-				if (set) {
-					el[key] = value;
-				} else {
-					return el[key];
-				}
-				break;
-			}
-		}
-	}
-
-	return {
-		getStyles: function(el) {
-			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
-				view = doc && doc.defaultView;
-			return view && view.getComputedStyle(el, '');
-		},
-
-		getBounds: function(el, viewport) {
-			var doc = el.ownerDocument,
-				body = doc.body,
-				html = doc.documentElement,
-				rect;
-			try {
-				rect = el.getBoundingClientRect();
-			} catch (e) {
-				rect = { left: 0, top: 0, width: 0, height: 0 };
-			}
-			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
-				y = rect.top - (html.clientTop || body.clientTop || 0);
-			if (!viewport) {
-				var view = doc.defaultView;
-				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
-				y += view.pageYOffset || html.scrollTop || body.scrollTop;
-			}
-			return new Rectangle(x, y, rect.width, rect.height);
-		},
-
-		getViewportBounds: function(el) {
-			var doc = el.ownerDocument,
-				view = doc.defaultView,
-				html = doc.documentElement;
-			return new Rectangle(0, 0,
-				view.innerWidth || html.clientWidth,
-				view.innerHeight || html.clientHeight
-			);
-		},
-
-		getOffset: function(el, viewport) {
-			return DomElement.getBounds(el, viewport).getPoint();
-		},
-
-		getSize: function(el) {
-			return DomElement.getBounds(el, true).getSize();
-		},
-
-		isInvisible: function(el) {
-			return DomElement.getSize(el).equals(new Size(0, 0));
-		},
-
-		isInView: function(el) {
-			return !DomElement.isInvisible(el)
-					&& DomElement.getViewportBounds(el).intersects(
-						DomElement.getBounds(el, true));
-		},
-
-		isInserted: function(el) {
-			return document.body.contains(el);
-		},
-
-		getPrefixed: function(el, name) {
-			return el && handlePrefix(el, name);
-		},
-
-		setPrefixed: function(el, name, value) {
-			if (typeof name === 'object') {
-				for (var key in name)
-					handlePrefix(el, key, true, name[key]);
-			} else {
-				handlePrefix(el, name, true, value);
-			}
-		}
-	};
-};
-
-var DomEvent = {
-	add: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++) {
-					var name = parts[i];
-					var options = (
-						el === document
-						&& (name === 'touchstart' || name === 'touchmove')
-					) ? { passive: false } : false;
-					el.addEventListener(name, func, options);
-				}
-			}
-		}
-	},
-
-	remove: function(el, events) {
-		if (el) {
-			for (var type in events) {
-				var func = events[type],
-					parts = type.split(/[\s,]+/g);
-				for (var i = 0, l = parts.length; i < l; i++)
-					el.removeEventListener(parts[i], func, false);
-			}
-		}
-	},
-
-	getPoint: function(event) {
-		var pos = event.targetTouches
-				? event.targetTouches.length
-					? event.targetTouches[0]
-					: event.changedTouches[0]
-				: event;
-		return new Point(
-			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
-			pos.pageY || pos.clientY + document.documentElement.scrollTop
-		);
-	},
-
-	getTarget: function(event) {
-		return event.target || event.srcElement;
-	},
-
-	getRelatedTarget: function(event) {
-		return event.relatedTarget || event.toElement;
-	},
-
-	getOffset: function(event, target) {
-		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
-				target || DomEvent.getTarget(event)));
-	}
-};
-
-DomEvent.requestAnimationFrame = new function() {
-	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
-		requested = false,
-		callbacks = [],
-		timer;
-
-	function handleCallbacks() {
-		var functions = callbacks;
-		callbacks = [];
-		for (var i = 0, l = functions.length; i < l; i++)
-			functions[i]();
-		requested = nativeRequest && callbacks.length;
-		if (requested)
-			nativeRequest(handleCallbacks);
-	}
-
-	return function(callback) {
-		callbacks.push(callback);
-		if (nativeRequest) {
-			if (!requested) {
-				nativeRequest(handleCallbacks);
-				requested = true;
-			}
-		} else if (!timer) {
-			timer = setInterval(handleCallbacks, 1000 / 60);
-		}
-	};
-};
-
-var View = Base.extend(Emitter, {
-	_class: 'View',
-
-	initialize: function View(project, element) {
-
-		function getSize(name) {
-			return element[name] || parseInt(element.getAttribute(name), 10);
-		}
-
-		function getCanvasSize() {
-			var size = DomElement.getSize(element);
-			return size.isNaN() || size.isZero()
-					? new Size(getSize('width'), getSize('height'))
-					: size;
-		}
-
-		var size;
-		if (window && element) {
-			this._id = element.getAttribute('id');
-			if (this._id == null)
-				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
-			DomEvent.add(element, this._viewEvents);
-			var none = 'none';
-			DomElement.setPrefixed(element.style, {
-				userDrag: none,
-				userSelect: none,
-				touchCallout: none,
-				contentZooming: none,
-				tapHighlightColor: 'rgba(0,0,0,0)'
-			});
-
-			if (PaperScope.hasAttribute(element, 'resize')) {
-				var that = this;
-				DomEvent.add(window, this._windowEvents = {
-					resize: function() {
-						that.setViewSize(getCanvasSize());
-					}
-				});
-			}
-
-			size = getCanvasSize();
-
-			if (PaperScope.hasAttribute(element, 'stats')
-					&& typeof Stats !== 'undefined') {
-				this._stats = new Stats();
-				var stats = this._stats.domElement,
-					style = stats.style,
-					offset = DomElement.getOffset(element);
-				style.position = 'absolute';
-				style.left = offset.x + 'px';
-				style.top = offset.y + 'px';
-				document.body.appendChild(stats);
-			}
-		} else {
-			size = new Size(element);
-			element = null;
-		}
-		this._project = project;
-		this._scope = project._scope;
-		this._element = element;
-		if (!this._pixelRatio)
-			this._pixelRatio = window && window.devicePixelRatio || 1;
-		this._setElementSize(size.width, size.height);
-		this._viewSize = size;
-		View._views.push(this);
-		View._viewsById[this._id] = this;
-		(this._matrix = new Matrix())._owner = this;
-		if (!View._focused)
-			View._focused = this;
-		this._frameItems = {};
-		this._frameItemCount = 0;
-		this._itemEvents = { native: {}, virtual: {} };
-		this._autoUpdate = !paper.agent.node;
-		this._needsUpdate = false;
-	},
-
-	remove: function() {
-		if (!this._project)
-			return false;
-		if (View._focused === this)
-			View._focused = null;
-		View._views.splice(View._views.indexOf(this), 1);
-		delete View._viewsById[this._id];
-		var project = this._project;
-		if (project._view === this)
-			project._view = null;
-		DomEvent.remove(this._element, this._viewEvents);
-		DomEvent.remove(window, this._windowEvents);
-		this._element = this._project = null;
-		this.off('frame');
-		this._animate = false;
-		this._frameItems = {};
-		return true;
-	},
-
-	_events: Base.each(
-		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
-		function(name) {
-			this[name] = {};
-		}, {
-			onFrame: {
-				install: function() {
-					this.play();
-				},
-
-				uninstall: function() {
-					this.pause();
-				}
-			}
-		}
-	),
-
-	_animate: false,
-	_time: 0,
-	_count: 0,
-
-	getAutoUpdate: function() {
-		return this._autoUpdate;
-	},
-
-	setAutoUpdate: function(autoUpdate) {
-		this._autoUpdate = autoUpdate;
-		if (autoUpdate)
-			this.requestUpdate();
-	},
-
-	update: function() {
-	},
-
-	draw: function() {
-		this.update();
-	},
-
-	requestUpdate: function() {
-		if (!this._requested) {
-			var that = this;
-			DomEvent.requestAnimationFrame(function() {
-				that._requested = false;
-				if (that._animate) {
-					that.requestUpdate();
-					var element = that._element;
-					if ((!DomElement.getPrefixed(document, 'hidden')
-							|| PaperScope.getAttribute(element, 'keepalive')
-								=== 'true') && DomElement.isInView(element)) {
-						that._handleFrame();
-					}
-				}
-				if (that._autoUpdate)
-					that.update();
-			});
-			this._requested = true;
-		}
-	},
-
-	play: function() {
-		this._animate = true;
-		this.requestUpdate();
-	},
-
-	pause: function() {
-		this._animate = false;
-	},
-
-	_handleFrame: function() {
-		paper = this._scope;
-		var now = Date.now() / 1000,
-			delta = this._last ? now - this._last : 0;
-		this._last = now;
-		this.emit('frame', new Base({
-			delta: delta,
-			time: this._time += delta,
-			count: this._count++
-		}));
-		if (this._stats)
-			this._stats.update();
-	},
-
-	_animateItem: function(item, animate) {
-		var items = this._frameItems;
-		if (animate) {
-			items[item._id] = {
-				item: item,
-				time: 0,
-				count: 0
-			};
-			if (++this._frameItemCount === 1)
-				this.on('frame', this._handleFrameItems);
-		} else {
-			delete items[item._id];
-			if (--this._frameItemCount === 0) {
-				this.off('frame', this._handleFrameItems);
-			}
-		}
-	},
-
-	_handleFrameItems: function(event) {
-		for (var i in this._frameItems) {
-			var entry = this._frameItems[i];
-			entry.item.emit('frame', new Base(event, {
-				time: entry.time += event.delta,
-				count: entry.count++
-			}));
-		}
-	},
-
-	_changed: function() {
-		this._project._changed(4097);
-		this._bounds = this._decomposed = undefined;
-	},
-
-	getElement: function() {
-		return this._element;
-	},
-
-	getPixelRatio: function() {
-		return this._pixelRatio;
-	},
-
-	getResolution: function() {
-		return this._pixelRatio * 72;
-	},
-
-	getViewSize: function() {
-		var size = this._viewSize;
-		return new LinkedSize(size.width, size.height, this, 'setViewSize');
-	},
-
-	setViewSize: function() {
-		var size = Size.read(arguments),
-			delta = size.subtract(this._viewSize);
-		if (delta.isZero())
-			return;
-		this._setElementSize(size.width, size.height);
-		this._viewSize.set(size);
-		this._changed();
-		this.emit('resize', { size: size, delta: delta });
-		if (this._autoUpdate) {
-			this.update();
-		}
-	},
-
-	_setElementSize: function(width, height) {
-		var element = this._element;
-		if (element) {
-			if (element.width !== width)
-				element.width = width;
-			if (element.height !== height)
-				element.height = height;
-		}
-	},
-
-	getBounds: function() {
-		if (!this._bounds)
-			this._bounds = this._matrix.inverted()._transformBounds(
-					new Rectangle(new Point(), this._viewSize));
-		return this._bounds;
-	},
-
-	getSize: function() {
-		return this.getBounds().getSize();
-	},
-
-	isVisible: function() {
-		return DomElement.isInView(this._element);
-	},
-
-	isInserted: function() {
-		return DomElement.isInserted(this._element);
-	},
-
-	getPixelSize: function(size) {
-		var element = this._element,
-			pixels;
-		if (element) {
-			var parent = element.parentNode,
-				temp = document.createElement('div');
-			temp.style.fontSize = size;
-			parent.appendChild(temp);
-			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
-			parent.removeChild(temp);
-		} else {
-			pixels = parseFloat(pixels);
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		return 0;
-	}
-}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
-	var rotate = key === 'rotate';
-	this[key] = function() {
-		var args = arguments,
-			value = (rotate ? Base : Point).read(args),
-			center = Point.read(args, 0, { readNull: true });
-		return this.transform(new Matrix()[key](value,
-				center || this.getCenter(true)));
-	};
-}, {
-	_decompose: function() {
-		return this._decomposed || (this._decomposed = this._matrix.decompose());
-	},
-
-	translate: function() {
-		var mx = new Matrix();
-		return this.transform(mx.translate.apply(mx, arguments));
-	},
-
-	getCenter: function() {
-		return this.getBounds().getCenter();
-	},
-
-	setCenter: function() {
-		var center = Point.read(arguments);
-		this.translate(this.getCenter().subtract(center));
-	},
-
-	getZoom: function() {
-		var scaling = this._decompose().scaling;
-		return (scaling.x + scaling.y) / 2;
-	},
-
-	setZoom: function(zoom) {
-		this.transform(new Matrix().scale(zoom / this.getZoom(),
-			this.getCenter()));
-	},
-
-	getRotation: function() {
-		return this._decompose().rotation;
-	},
-
-	setRotation: function(rotation) {
-		var current = this.getRotation();
-		if (current != null && rotation != null) {
-			this.rotate(rotation - current);
-		}
-	},
-
-	getScaling: function() {
-		var scaling = this._decompose().scaling;
-		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
-	},
-
-	setScaling: function() {
-		var current = this.getScaling(),
-			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
-		if (current && scaling) {
-			this.scale(scaling.x / current.x, scaling.y / current.y);
-		}
-	},
-
-	getMatrix: function() {
-		return this._matrix;
-	},
-
-	setMatrix: function() {
-		var matrix = this._matrix;
-		matrix.initialize.apply(matrix, arguments);
-	},
-
-	transform: function(matrix) {
-		this._matrix.append(matrix);
-	},
-
-	scrollBy: function() {
-		this.translate(Point.read(arguments).negate());
-	}
-}), {
-
-	projectToView: function() {
-		return this._matrix._transformPoint(Point.read(arguments));
-	},
-
-	viewToProject: function() {
-		return this._matrix._inverseTransform(Point.read(arguments));
-	},
-
-	getEventPoint: function(event) {
-		return this.viewToProject(DomEvent.getOffset(event, this._element));
-	},
-
-}, {
-	statics: {
-		_views: [],
-		_viewsById: {},
-		_id: 0,
-
-		create: function(project, element) {
-			if (document && typeof element === 'string')
-				element = document.getElementById(element);
-			var ctor = window ? CanvasView : View;
-			return new ctor(project, element);
-		}
-	}
-},
-new function() {
-	if (!window)
-		return;
-	var prevFocus,
-		tempFocus,
-		dragging = false,
-		mouseDown = false;
-
-	function getView(event) {
-		var target = DomEvent.getTarget(event);
-		return target.getAttribute && View._viewsById[
-				target.getAttribute('id')];
-	}
-
-	function updateFocus() {
-		var view = View._focused;
-		if (!view || !view.isVisible()) {
-			for (var i = 0, l = View._views.length; i < l; i++) {
-				if ((view = View._views[i]).isVisible()) {
-					View._focused = tempFocus = view;
-					break;
-				}
-			}
-		}
-	}
-
-	function handleMouseMove(view, event, point) {
-		view._handleMouseEvent('mousemove', event, point);
-	}
-
-	var navigator = window.navigator,
-		mousedown, mousemove, mouseup;
-	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
-		mousedown = 'pointerdown MSPointerDown';
-		mousemove = 'pointermove MSPointerMove';
-		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
-	} else {
-		mousedown = 'touchstart';
-		mousemove = 'touchmove';
-		mouseup = 'touchend touchcancel';
-		if (!('ontouchstart' in window && navigator.userAgent.match(
-				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
-			mousedown += ' mousedown';
-			mousemove += ' mousemove';
-			mouseup += ' mouseup';
-		}
-	}
-
-	var viewEvents = {},
-		docEvents = {
-			mouseout: function(event) {
-				var view = View._focused,
-					target = DomEvent.getRelatedTarget(event);
-				if (view && (!target || target.nodeName === 'HTML')) {
-					var offset = DomEvent.getOffset(event, view._element),
-						x = offset.x,
-						abs = Math.abs,
-						ax = abs(x),
-						max = 1 << 25,
-						diff = ax - max;
-					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
-					handleMouseMove(view, event, view.viewToProject(offset));
-				}
-			},
-
-			scroll: updateFocus
-		};
-
-	viewEvents[mousedown] = function(event) {
-		var view = View._focused = getView(event);
-		if (!dragging) {
-			dragging = true;
-			view._handleMouseEvent('mousedown', event);
-		}
-	};
-
-	docEvents[mousemove] = function(event) {
-		var view = View._focused;
-		if (!mouseDown) {
-			var target = getView(event);
-			if (target) {
-				if (view !== target) {
-					if (view)
-						handleMouseMove(view, event);
-					if (!prevFocus)
-						prevFocus = view;
-					view = View._focused = tempFocus = target;
-				}
-			} else if (tempFocus && tempFocus === view) {
-				if (prevFocus && !prevFocus.isInserted())
-					prevFocus = null;
-				view = View._focused = prevFocus;
-				prevFocus = null;
-				updateFocus();
-			}
-		}
-		if (view)
-			handleMouseMove(view, event);
-	};
-
-	docEvents[mousedown] = function() {
-		mouseDown = true;
-	};
-
-	docEvents[mouseup] = function(event) {
-		var view = View._focused;
-		if (view && dragging)
-			view._handleMouseEvent('mouseup', event);
-		mouseDown = dragging = false;
-	};
-
-	DomEvent.add(document, docEvents);
-
-	DomEvent.add(window, {
-		load: updateFocus
-	});
-
-	var called = false,
-		prevented = false,
-		fallbacks = {
-			doubleclick: 'click',
-			mousedrag: 'mousemove'
-		},
-		wasInView = false,
-		overView,
-		downPoint,
-		lastPoint,
-		downItem,
-		overItem,
-		dragItem,
-		clickItem,
-		clickTime,
-		dblClick;
-
-	function emitMouseEvent(obj, target, type, event, point, prevPoint,
-			stopItem) {
-		var stopped = false,
-			mouseEvent;
-
-		function emit(obj, type) {
-			if (obj.responds(type)) {
-				if (!mouseEvent) {
-					mouseEvent = new MouseEvent(type, event, point,
-							target || obj,
-							prevPoint ? point.subtract(prevPoint) : null);
-				}
-				if (obj.emit(type, mouseEvent)) {
-					called = true;
-					if (mouseEvent.prevented)
-						prevented = true;
-					if (mouseEvent.stopped)
-						return stopped = true;
-				}
-			} else {
-				var fallback = fallbacks[type];
-				if (fallback)
-					return emit(obj, fallback);
-			}
-		}
-
-		while (obj && obj !== stopItem) {
-			if (emit(obj, type))
-				break;
-			obj = obj._parent;
-		}
-		return stopped;
-	}
-
-	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
-		view._project.removeOn(type);
-		prevented = called = false;
-		return (dragItem && emitMouseEvent(dragItem, null, type, event,
-					point, prevPoint)
-			|| hitItem && hitItem !== dragItem
-				&& !hitItem.isDescendant(dragItem)
-				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
-					'mousemove' : type, event, point, prevPoint, dragItem)
-			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
-					point, prevPoint));
-	}
-
-	var itemEventsMap = {
-		mousedown: {
-			mousedown: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mouseup: {
-			mouseup: 1,
-			mousedrag: 1,
-			click: 1,
-			doubleclick: 1
-		},
-		mousemove: {
-			mousedrag: 1,
-			mousemove: 1,
-			mouseenter: 1,
-			mouseleave: 1
-		}
-	};
-
-	return {
-		_viewEvents: viewEvents,
-
-		_handleMouseEvent: function(type, event, point) {
-			var itemEvents = this._itemEvents,
-				hitItems = itemEvents.native[type],
-				nativeMove = type === 'mousemove',
-				tool = this._scope.tool,
-				view = this;
-
-			function responds(type) {
-				return itemEvents.virtual[type] || view.responds(type)
-						|| tool && tool.responds(type);
-			}
-
-			if (nativeMove && dragging && responds('mousedrag'))
-				type = 'mousedrag';
-			if (!point)
-				point = this.getEventPoint(event);
-
-			var inView = this.getBounds().contains(point),
-				hit = hitItems && inView && view._project.hitTest(point, {
-					tolerance: 0,
-					fill: true,
-					stroke: true
-				}),
-				hitItem = hit && hit.item || null,
-				handle = false,
-				mouse = {};
-			mouse[type.substr(5)] = true;
-
-			if (hitItems && hitItem !== overItem) {
-				if (overItem) {
-					emitMouseEvent(overItem, null, 'mouseleave', event, point);
-				}
-				if (hitItem) {
-					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
-				}
-				overItem = hitItem;
-			}
-			if (wasInView ^ inView) {
-				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
-						event, point);
-				overView = inView ? this : null;
-				handle = true;
-			}
-			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
-				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
-						event, point, lastPoint);
-				handle = true;
-			}
-			wasInView = inView;
-			if (mouse.down && inView || mouse.up && downPoint) {
-				emitMouseEvents(this, hitItem, type, event, point, downPoint);
-				if (mouse.down) {
-					dblClick = hitItem === clickItem
-						&& (Date.now() - clickTime < 300);
-					downItem = clickItem = hitItem;
-					if (!prevented && hitItem) {
-						var item = hitItem;
-						while (item && !item.responds('mousedrag'))
-							item = item._parent;
-						if (item)
-							dragItem = hitItem;
-					}
-					downPoint = point;
-				} else if (mouse.up) {
-					if (!prevented && hitItem === downItem) {
-						clickTime = Date.now();
-						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
-								: 'click', event, point, downPoint);
-						dblClick = false;
-					}
-					downItem = dragItem = null;
-				}
-				wasInView = false;
-				handle = true;
-			}
-			lastPoint = point;
-			if (handle && tool) {
-				called = tool._handleMouseEvent(type, event, point, mouse)
-					|| called;
-			}
-
-			if (
-				event.cancelable !== false
-				&& (called && !mouse.move || mouse.down && responds('mouseup'))
-			) {
-				event.preventDefault();
-			}
-		},
-
-		_handleKeyEvent: function(type, event, key, character) {
-			var scope = this._scope,
-				tool = scope.tool,
-				keyEvent;
-
-			function emit(obj) {
-				if (obj.responds(type)) {
-					paper = scope;
-					obj.emit(type, keyEvent = keyEvent
-							|| new KeyEvent(type, event, key, character));
-				}
-			}
-
-			if (this.isVisible()) {
-				emit(this);
-				if (tool && tool.responds(type))
-					emit(tool);
-			}
-		},
-
-		_countItemEvent: function(type, sign) {
-			var itemEvents = this._itemEvents,
-				native = itemEvents.native,
-				virtual = itemEvents.virtual;
-			for (var key in itemEventsMap) {
-				native[key] = (native[key] || 0)
-						+ (itemEventsMap[key][type] || 0) * sign;
-			}
-			virtual[type] = (virtual[type] || 0) + sign;
-		},
-
-		statics: {
-			updateFocus: updateFocus,
-
-			_resetState: function() {
-				dragging = mouseDown = called = wasInView = false;
-				prevFocus = tempFocus = overView = downPoint = lastPoint =
-					downItem = overItem = dragItem = clickItem = clickTime =
-					dblClick = null;
-			}
-		}
-	};
-});
-
-var CanvasView = View.extend({
-	_class: 'CanvasView',
-
-	initialize: function CanvasView(project, canvas) {
-		if (!(canvas instanceof window.HTMLCanvasElement)) {
-			var size = Size.read(arguments, 1);
-			if (size.isZero())
-				throw new Error(
-						'Cannot create CanvasView with the provided argument: '
-						+ Base.slice(arguments, 1));
-			canvas = CanvasProvider.getCanvas(size);
-		}
-		var ctx = this._context = canvas.getContext('2d');
-		ctx.save();
-		this._pixelRatio = 1;
-		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
-			var deviceRatio = window.devicePixelRatio || 1,
-				backingStoreRatio = DomElement.getPrefixed(ctx,
-						'backingStorePixelRatio') || 1;
-			this._pixelRatio = deviceRatio / backingStoreRatio;
-		}
-		View.call(this, project, canvas);
-		this._needsUpdate = true;
-	},
-
-	remove: function remove() {
-		this._context.restore();
-		return remove.base.call(this);
-	},
-
-	_setElementSize: function _setElementSize(width, height) {
-		var pixelRatio = this._pixelRatio;
-		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
-		if (pixelRatio !== 1) {
-			var element = this._element,
-				ctx = this._context;
-			if (!PaperScope.hasAttribute(element, 'resize')) {
-				var style = element.style;
-				style.width = width + 'px';
-				style.height = height + 'px';
-			}
-			ctx.restore();
-			ctx.save();
-			ctx.scale(pixelRatio, pixelRatio);
-		}
-	},
-
-	getContext: function() {
-		return this._context;
-	},
-
-	getPixelSize: function getPixelSize(size) {
-		var agent = paper.agent,
-			pixels;
-		if (agent && agent.firefox) {
-			pixels = getPixelSize.base.call(this, size);
-		} else {
-			var ctx = this._context,
-				prevFont = ctx.font;
-			ctx.font = size + ' serif';
-			pixels = parseFloat(ctx.font);
-			ctx.font = prevFont;
-		}
-		return pixels;
-	},
-
-	getTextWidth: function(font, lines) {
-		var ctx = this._context,
-			prevFont = ctx.font,
-			width = 0;
-		ctx.font = font;
-		for (var i = 0, l = lines.length; i < l; i++)
-			width = Math.max(width, ctx.measureText(lines[i]).width);
-		ctx.font = prevFont;
-		return width;
-	},
-
-	update: function() {
-		if (!this._needsUpdate)
-			return false;
-		var project = this._project,
-			ctx = this._context,
-			size = this._viewSize;
-		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
-		if (project)
-			project.draw(ctx, this._matrix, this._pixelRatio);
-		this._needsUpdate = false;
-		return true;
-	}
-});
-
-var Event = Base.extend({
-	_class: 'Event',
-
-	initialize: function Event(event) {
-		this.event = event;
-		this.type = event && event.type;
-	},
-
-	prevented: false,
-	stopped: false,
-
-	preventDefault: function() {
-		this.prevented = true;
-		this.event.preventDefault();
-	},
-
-	stopPropagation: function() {
-		this.stopped = true;
-		this.event.stopPropagation();
-	},
-
-	stop: function() {
-		this.stopPropagation();
-		this.preventDefault();
-	},
-
-	getTimeStamp: function() {
-		return this.event.timeStamp;
-	},
-
-	getModifiers: function() {
-		return Key.modifiers;
-	}
-});
-
-var KeyEvent = Event.extend({
-	_class: 'KeyEvent',
-
-	initialize: function KeyEvent(type, event, key, character) {
-		this.type = type;
-		this.event = event;
-		this.key = key;
-		this.character = character;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', key: '" + this.key
-				+ "', character: '" + this.character
-				+ "', modifiers: " + this.getModifiers()
-				+ " }";
-	}
-});
-
-var Key = new function() {
-	var keyLookup = {
-			'\t': 'tab',
-			' ': 'space',
-			'\b': 'backspace',
-			'\x7f': 'delete',
-			'Spacebar': 'space',
-			'Del': 'delete',
-			'Win': 'meta',
-			'Esc': 'escape'
-		},
-
-		charLookup = {
-			'tab': '\t',
-			'space': ' ',
-			'enter': '\r'
-		},
-
-		keyMap = {},
-		charMap = {},
-		metaFixMap,
-		downKey,
-
-		modifiers = new Base({
-			shift: false,
-			control: false,
-			alt: false,
-			meta: false,
-			capsLock: false,
-			space: false
-		}).inject({
-			option: {
-				get: function() {
-					return this.alt;
-				}
-			},
-
-			command: {
-				get: function() {
-					var agent = paper && paper.agent;
-					return agent && agent.mac ? this.meta : this.control;
-				}
-			}
-		});
-
-	function getKey(event) {
-		var key = event.key || event.keyIdentifier;
-		key = /^U\+/.test(key)
-				? String.fromCharCode(parseInt(key.substr(2), 16))
-				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
-				: key === 'Unidentified'  || key === undefined
-					? String.fromCharCode(event.keyCode)
-					: key;
-		return keyLookup[key] ||
-				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
-	}
-
-	function handleKey(down, key, character, event) {
-		var type = down ? 'keydown' : 'keyup',
-			view = View._focused,
-			name;
-		keyMap[key] = down;
-		if (down) {
-			charMap[key] = character;
-		} else {
-			delete charMap[key];
-		}
-		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
-			modifiers[name] = down;
-			var agent = paper && paper.agent;
-			if (name === 'meta' && agent && agent.mac) {
-				if (down) {
-					metaFixMap = {};
-				} else {
-					for (var k in metaFixMap) {
-						if (k in charMap)
-							handleKey(false, k, metaFixMap[k], event);
-					}
-					metaFixMap = null;
-				}
-			}
-		} else if (down && metaFixMap) {
-			metaFixMap[key] = character;
-		}
-		if (view) {
-			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
-					character);
-		}
-	}
-
-	DomEvent.add(document, {
-		keydown: function(event) {
-			var key = getKey(event),
-				agent = paper && paper.agent;
-			if (key.length > 1 || agent && (agent.chrome && (event.altKey
-						|| agent.mac && event.metaKey
-						|| !agent.mac && event.ctrlKey))) {
-				handleKey(true, key,
-						charLookup[key] || (key.length > 1 ? '' : key), event);
-			} else {
-				downKey = key;
-			}
-		},
-
-		keypress: function(event) {
-			if (downKey) {
-				var key = getKey(event),
-					code = event.charCode,
-					character = code >= 32 ? String.fromCharCode(code)
-						: key.length > 1 ? '' : key;
-				if (key !== downKey) {
-					key = character.toLowerCase();
-				}
-				handleKey(true, key, character, event);
-				downKey = null;
-			}
-		},
-
-		keyup: function(event) {
-			var key = getKey(event);
-			if (key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	DomEvent.add(window, {
-		blur: function(event) {
-			for (var key in charMap)
-				handleKey(false, key, charMap[key], event);
-		}
-	});
-
-	return {
-		modifiers: modifiers,
-
-		isDown: function(key) {
-			return !!keyMap[key];
-		}
-	};
-};
-
-var MouseEvent = Event.extend({
-	_class: 'MouseEvent',
-
-	initialize: function MouseEvent(type, event, point, target, delta) {
-		this.type = type;
-		this.event = event;
-		this.point = point;
-		this.target = target;
-		this.delta = delta;
-	},
-
-	toString: function() {
-		return "{ type: '" + this.type
-				+ "', point: " + this.point
-				+ ', target: ' + this.target
-				+ (this.delta ? ', delta: ' + this.delta : '')
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var ToolEvent = Event.extend({
-	_class: 'ToolEvent',
-	_item: null,
-
-	initialize: function ToolEvent(tool, type, event) {
-		this.tool = tool;
-		this.type = type;
-		this.event = event;
-	},
-
-	_choosePoint: function(point, toolPoint) {
-		return point ? point : toolPoint ? toolPoint.clone() : null;
-	},
-
-	getPoint: function() {
-		return this._choosePoint(this._point, this.tool._point);
-	},
-
-	setPoint: function(point) {
-		this._point = point;
-	},
-
-	getLastPoint: function() {
-		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
-	},
-
-	setLastPoint: function(lastPoint) {
-		this._lastPoint = lastPoint;
-	},
-
-	getDownPoint: function() {
-		return this._choosePoint(this._downPoint, this.tool._downPoint);
-	},
-
-	setDownPoint: function(downPoint) {
-		this._downPoint = downPoint;
-	},
-
-	getMiddlePoint: function() {
-		if (!this._middlePoint && this.tool._lastPoint) {
-			return this.tool._point.add(this.tool._lastPoint).divide(2);
-		}
-		return this._middlePoint;
-	},
-
-	setMiddlePoint: function(middlePoint) {
-		this._middlePoint = middlePoint;
-	},
-
-	getDelta: function() {
-		return !this._delta && this.tool._lastPoint
-				? this.tool._point.subtract(this.tool._lastPoint)
-				: this._delta;
-	},
-
-	setDelta: function(delta) {
-		this._delta = delta;
-	},
-
-	getCount: function() {
-		return this.tool[/^mouse(down|up)$/.test(this.type)
-				? '_downCount' : '_moveCount'];
-	},
-
-	setCount: function(count) {
-		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
-			= count;
-	},
-
-	getItem: function() {
-		if (!this._item) {
-			var result = this.tool._scope.project.hitTest(this.getPoint());
-			if (result) {
-				var item = result.item,
-					parent = item._parent;
-				while (/^(Group|CompoundPath)$/.test(parent._class)) {
-					item = parent;
-					parent = parent._parent;
-				}
-				this._item = item;
-			}
-		}
-		return this._item;
-	},
-
-	setItem: function(item) {
-		this._item = item;
-	},
-
-	toString: function() {
-		return '{ type: ' + this.type
-				+ ', point: ' + this.getPoint()
-				+ ', count: ' + this.getCount()
-				+ ', modifiers: ' + this.getModifiers()
-				+ ' }';
-	}
-});
-
-var Tool = PaperScopeItem.extend({
-	_class: 'Tool',
-	_list: 'tools',
-	_reference: 'tool',
-	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
-			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
-			'onKeyUp'],
-
-	initialize: function Tool(props) {
-		PaperScopeItem.call(this);
-		this._moveCount = -1;
-		this._downCount = -1;
-		this.set(props);
-	},
-
-	getMinDistance: function() {
-		return this._minDistance;
-	},
-
-	setMinDistance: function(minDistance) {
-		this._minDistance = minDistance;
-		if (minDistance != null && this._maxDistance != null
-				&& minDistance > this._maxDistance) {
-			this._maxDistance = minDistance;
-		}
-	},
-
-	getMaxDistance: function() {
-		return this._maxDistance;
-	},
-
-	setMaxDistance: function(maxDistance) {
-		this._maxDistance = maxDistance;
-		if (this._minDistance != null && maxDistance != null
-				&& maxDistance < this._minDistance) {
-			this._minDistance = maxDistance;
-		}
-	},
-
-	getFixedDistance: function() {
-		return this._minDistance == this._maxDistance
-			? this._minDistance : null;
-	},
-
-	setFixedDistance: function(distance) {
-		this._minDistance = this._maxDistance = distance;
-	},
-
-	_handleMouseEvent: function(type, event, point, mouse) {
-		paper = this._scope;
-		if (mouse.drag && !this.responds(type))
-			type = 'mousemove';
-		var move = mouse.move || mouse.drag,
-			responds = this.responds(type),
-			minDistance = this.minDistance,
-			maxDistance = this.maxDistance,
-			called = false,
-			tool = this;
-		function update(minDistance, maxDistance) {
-			var pt = point,
-				toolPoint = move ? tool._point : (tool._downPoint || pt);
-			if (move) {
-				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
-					return false;
-				}
-				if (toolPoint && (minDistance != null || maxDistance != null)) {
-					var vector = pt.subtract(toolPoint),
-						distance = vector.getLength();
-					if (distance < (minDistance || 0))
-						return false;
-					if (maxDistance) {
-						pt = toolPoint.add(vector.normalize(
-								Math.min(distance, maxDistance)));
-					}
-				}
-				tool._moveCount++;
-			}
-			tool._point = pt;
-			tool._lastPoint = toolPoint || pt;
-			if (mouse.down) {
-				tool._moveCount = -1;
-				tool._downPoint = pt;
-				tool._downCount++;
-			}
-			return true;
-		}
-
-		function emit() {
-			if (responds) {
-				called = tool.emit(type, new ToolEvent(tool, type, event))
-						|| called;
-			}
-		}
-
-		if (mouse.down) {
-			update();
-			emit();
-		} else if (mouse.up) {
-			update(null, maxDistance);
-			emit();
-		} else if (responds) {
-			while (update(minDistance, maxDistance))
-				emit();
-		}
-		return called;
-	}
-
-});
-
-var Tween = Base.extend(Emitter, {
-	_class: 'Tween',
-
-	statics: {
-		easings: {
-			linear: function(t) {
-				return t;
-			},
-
-			easeInQuad: function(t) {
-				return t * t;
-			},
-
-			easeOutQuad: function(t) {
-				return t * (2 - t);
-			},
-
-			easeInOutQuad: function(t) {
-				return t < 0.5
-					? 2 * t * t
-					: -1 + 2 * (2 - t) * t;
-			},
-
-			easeInCubic: function(t) {
-				return t * t * t;
-			},
-
-			easeOutCubic: function(t) {
-				return --t * t * t + 1;
-			},
-
-			easeInOutCubic: function(t) {
-				return t < 0.5
-					? 4 * t * t * t
-					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-			},
-
-			easeInQuart: function(t) {
-				return t * t * t * t;
-			},
-
-			easeOutQuart: function(t) {
-				return 1 - (--t) * t * t * t;
-			},
-
-			easeInOutQuart: function(t) {
-				return t < 0.5
-					? 8 * t * t * t * t
-					: 1 - 8 * (--t) * t * t * t;
-			},
-
-			easeInQuint: function(t) {
-				return t * t * t * t * t;
-			},
-
-			easeOutQuint: function(t) {
-				return 1 + --t * t * t * t * t;
-			},
-
-			easeInOutQuint: function(t) {
-				return t < 0.5
-					? 16 * t * t * t * t * t
-					: 1 + 16 * (--t) * t * t * t * t;
-			}
-		}
-	},
-
-	initialize: function Tween(object, from, to, duration, easing, start) {
-		this.object = object;
-		var type = typeof easing;
-		var isFunction = type === 'function';
-		this.type = isFunction
-			? type
-			: type === 'string'
-				? easing
-				: 'linear';
-		this.easing = isFunction ? easing : Tween.easings[this.type];
-		this.duration = duration;
-		this.running = false;
-
-		this._then = null;
-		this._startTime = null;
-		var state = from || to;
-		this._keys = state ? Object.keys(state) : [];
-		this._parsedKeys = this._parseKeys(this._keys);
-		this._from = state && this._getState(from);
-		this._to = state && this._getState(to);
-		if (start !== false) {
-			this.start();
-		}
-	},
-
-	then: function(then) {
-		this._then = then;
-		return this;
-	},
-
-	start: function() {
-		this._startTime = null;
-		this.running = true;
-		return this;
-	},
-
-	stop: function() {
-		this.running = false;
-		return this;
-	},
-
-	update: function(progress) {
-		if (this.running) {
-			if (progress > 1) {
-				progress = 1;
-				this.running = false;
-			}
-
-			var factor = this.easing(progress),
-				keys = this._keys,
-				getValue = function(value) {
-					return typeof value === 'function'
-						? value(factor, progress)
-						: value;
-				};
-			for (var i = 0, l = keys && keys.length; i < l; i++) {
-				var key = keys[i],
-					from = getValue(this._from[key]),
-					to = getValue(this._to[key]),
-					value = (from && to && from.__add && to.__add)
-						? to.__subtract(from).__multiply(factor).__add(from)
-						: ((to - from) * factor) + from;
-				this._setProperty(this._parsedKeys[key], value);
-			}
-
-			if (!this.running && this._then) {
-				this._then(this.object);
-			}
-			if (this.responds('update')) {
-				this.emit('update', new Base({
-					progress: progress,
-					factor: factor
-				}));
-			}
-		}
-		return this;
-	},
-
-	_events: {
-		onUpdate: {}
-	},
-
-	_handleFrame: function(time) {
-		var startTime = this._startTime,
-			progress = startTime
-				? (time - startTime) / this.duration
-				: 0;
-		if (!startTime) {
-			this._startTime = time;
-		}
-		this.update(progress);
-	},
-
-	_getState: function(state) {
-		var keys = this._keys,
-			result = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = this._parsedKeys[key],
-				current = this._getProperty(path),
-				value;
-			if (state) {
-				var resolved = this._resolveValue(current, state[key]);
-				this._setProperty(path, resolved);
-				value = this._getProperty(path);
-				value = value && value.clone ? value.clone() : value;
-				this._setProperty(path, current);
-			} else {
-				value = current && current.clone ? current.clone() : current;
-			}
-			result[key] = value;
-		}
-		return result;
-	},
-
-	_resolveValue: function(current, value) {
-		if (value) {
-			if (Array.isArray(value) && value.length === 2) {
-				var operator = value[0];
-				return (
-					operator &&
-					operator.match &&
-					operator.match(/^[+\-\*\/]=/)
-				)
-					? this._calculate(current, operator[0], value[1])
-					: value;
-			} else if (typeof value === 'string') {
-				var match = value.match(/^[+\-*/]=(.*)/);
-				if (match) {
-					var parsed = JSON.parse(match[1].replace(
-						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
-						'"$2": '
-					));
-					return this._calculate(current, value[0], parsed);
-				}
-			}
-		}
-		return value;
-	},
-
-	_calculate: function(left, operator, right) {
-		return paper.PaperScript.calculateBinary(left, operator, right);
-	},
-
-	_parseKeys: function(keys) {
-		var parsed = {};
-		for (var i = 0, l = keys.length; i < l; i++) {
-			var key = keys[i],
-				path = key
-					.replace(/\.([^.]*)/g, '/$1')
-					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
-			parsed[key] = path.split('/');
-		}
-		return parsed;
-	},
-
-	_getProperty: function(path, offset) {
-		var obj = this.object;
-		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
-			obj = obj[path[i]];
-		}
-		return obj;
-	},
-
-	_setProperty: function(path, value) {
-		var dest = this._getProperty(path, 1);
-		if (dest) {
-			dest[path[path.length - 1]] = value;
-		}
-	}
-});
-
-var Http = {
-	request: function(options) {
-		var xhr = new self.XMLHttpRequest();
-		xhr.open((options.method || 'get').toUpperCase(), options.url,
-				Base.pick(options.async, true));
-		if (options.mimeType)
-			xhr.overrideMimeType(options.mimeType);
-		xhr.onload = function() {
-			var status = xhr.status;
-			if (status === 0 || status === 200) {
-				if (options.onLoad) {
-					options.onLoad.call(xhr, xhr.responseText);
-				}
-			} else {
-				xhr.onerror();
-			}
-		};
-		xhr.onerror = function() {
-			var status = xhr.status,
-				message = 'Could not load "' + options.url + '" (Status: '
-						+ status + ')';
-			if (options.onError) {
-				options.onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		};
-		return xhr.send(null);
-	}
-};
-
-var CanvasProvider = {
-	canvases: [],
-
-	getCanvas: function(width, height) {
-		if (!window)
-			return null;
-		var canvas,
-			clear = true;
-		if (typeof width === 'object') {
-			height = width.height;
-			width = width.width;
-		}
-		if (this.canvases.length) {
-			canvas = this.canvases.pop();
-		} else {
-			canvas = document.createElement('canvas');
-			clear = false;
-		}
-		var ctx = canvas.getContext('2d');
-		if (!ctx) {
-			throw new Error('Canvas ' + canvas +
-					' is unable to provide a 2D context.');
-		}
-		if (canvas.width === width && canvas.height === height) {
-			if (clear)
-				ctx.clearRect(0, 0, width + 1, height + 1);
-		} else {
-			canvas.width = width;
-			canvas.height = height;
-		}
-		ctx.save();
-		return canvas;
-	},
-
-	getContext: function(width, height) {
-		var canvas = this.getCanvas(width, height);
-		return canvas ? canvas.getContext('2d') : null;
-	},
-
-	release: function(obj) {
-		var canvas = obj && obj.canvas ? obj.canvas : obj;
-		if (canvas && canvas.getContext) {
-			canvas.getContext('2d').restore();
-			this.canvases.push(canvas);
-		}
-	}
-};
-
-var BlendMode = new function() {
-	var min = Math.min,
-		max = Math.max,
-		abs = Math.abs,
-		sr, sg, sb, sa,
-		br, bg, bb, ba,
-		dr, dg, db;
-
-	function getLum(r, g, b) {
-		return 0.2989 * r + 0.587 * g + 0.114 * b;
-	}
-
-	function setLum(r, g, b, l) {
-		var d = l - getLum(r, g, b);
-		dr = r + d;
-		dg = g + d;
-		db = b + d;
-		var l = getLum(dr, dg, db),
-			mn = min(dr, dg, db),
-			mx = max(dr, dg, db);
-		if (mn < 0) {
-			var lmn = l - mn;
-			dr = l + (dr - l) * l / lmn;
-			dg = l + (dg - l) * l / lmn;
-			db = l + (db - l) * l / lmn;
-		}
-		if (mx > 255) {
-			var ln = 255 - l,
-				mxl = mx - l;
-			dr = l + (dr - l) * ln / mxl;
-			dg = l + (dg - l) * ln / mxl;
-			db = l + (db - l) * ln / mxl;
-		}
-	}
-
-	function getSat(r, g, b) {
-		return max(r, g, b) - min(r, g, b);
-	}
-
-	function setSat(r, g, b, s) {
-		var col = [r, g, b],
-			mx = max(r, g, b),
-			mn = min(r, g, b),
-			md;
-		mn = mn === r ? 0 : mn === g ? 1 : 2;
-		mx = mx === r ? 0 : mx === g ? 1 : 2;
-		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
-		if (col[mx] > col[mn]) {
-			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
-			col[mx] = s;
-		} else {
-			col[md] = col[mx] = 0;
-		}
-		col[mn] = 0;
-		dr = col[0];
-		dg = col[1];
-		db = col[2];
-	}
-
-	var modes = {
-		multiply: function() {
-			dr = br * sr / 255;
-			dg = bg * sg / 255;
-			db = bb * sb / 255;
-		},
-
-		screen: function() {
-			dr = br + sr - (br * sr / 255);
-			dg = bg + sg - (bg * sg / 255);
-			db = bb + sb - (bb * sb / 255);
-		},
-
-		overlay: function() {
-			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
-			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
-			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
-		},
-
-		'soft-light': function() {
-			var t = sr * br / 255;
-			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
-			t = sg * bg / 255;
-			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
-			t = sb * bb / 255;
-			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
-		},
-
-		'hard-light': function() {
-			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
-			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
-			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
-		},
-
-		'color-dodge': function() {
-			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
-			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
-			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
-		},
-
-		'color-burn': function() {
-			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
-			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
-			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
-		},
-
-		darken: function() {
-			dr = br < sr ? br : sr;
-			dg = bg < sg ? bg : sg;
-			db = bb < sb ? bb : sb;
-		},
-
-		lighten: function() {
-			dr = br > sr ? br : sr;
-			dg = bg > sg ? bg : sg;
-			db = bb > sb ? bb : sb;
-		},
-
-		difference: function() {
-			dr = br - sr;
-			if (dr < 0)
-				dr = -dr;
-			dg = bg - sg;
-			if (dg < 0)
-				dg = -dg;
-			db = bb - sb;
-			if (db < 0)
-				db = -db;
-		},
-
-		exclusion: function() {
-			dr = br + sr * (255 - br - br) / 255;
-			dg = bg + sg * (255 - bg - bg) / 255;
-			db = bb + sb * (255 - bb - bb) / 255;
-		},
-
-		hue: function() {
-			setSat(sr, sg, sb, getSat(br, bg, bb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		saturation: function() {
-			setSat(br, bg, bb, getSat(sr, sg, sb));
-			setLum(dr, dg, db, getLum(br, bg, bb));
-		},
-
-		luminosity: function() {
-			setLum(br, bg, bb, getLum(sr, sg, sb));
-		},
-
-		color: function() {
-			setLum(sr, sg, sb, getLum(br, bg, bb));
-		},
-
-		add: function() {
-			dr = min(br + sr, 255);
-			dg = min(bg + sg, 255);
-			db = min(bb + sb, 255);
-		},
-
-		subtract: function() {
-			dr = max(br - sr, 0);
-			dg = max(bg - sg, 0);
-			db = max(bb - sb, 0);
-		},
-
-		average: function() {
-			dr = (br + sr) / 2;
-			dg = (bg + sg) / 2;
-			db = (bb + sb) / 2;
-		},
-
-		negation: function() {
-			dr = 255 - abs(255 - sr - br);
-			dg = 255 - abs(255 - sg - bg);
-			db = 255 - abs(255 - sb - bb);
-		}
-	};
-
-	var nativeModes = this.nativeModes = Base.each([
-		'source-over', 'source-in', 'source-out', 'source-atop',
-		'destination-over', 'destination-in', 'destination-out',
-		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
-	], function(mode) {
-		this[mode] = true;
-	}, {});
-
-	var ctx = CanvasProvider.getContext(1, 1);
-	if (ctx) {
-		Base.each(modes, function(func, mode) {
-			var darken = mode === 'darken',
-				ok = false;
-			ctx.save();
-			try {
-				ctx.fillStyle = darken ? '#300' : '#a00';
-				ctx.fillRect(0, 0, 1, 1);
-				ctx.globalCompositeOperation = mode;
-				if (ctx.globalCompositeOperation === mode) {
-					ctx.fillStyle = darken ? '#a00' : '#300';
-					ctx.fillRect(0, 0, 1, 1);
-					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
-							? 170 : 51;
-				}
-			} catch (e) {}
-			ctx.restore();
-			nativeModes[mode] = ok;
-		});
-		CanvasProvider.release(ctx);
-	}
-
-	this.process = function(mode, srcContext, dstContext, alpha, offset) {
-		var srcCanvas = srcContext.canvas,
-			normal = mode === 'normal';
-		if (normal || nativeModes[mode]) {
-			dstContext.save();
-			dstContext.setTransform(1, 0, 0, 1, 0, 0);
-			dstContext.globalAlpha = alpha;
-			if (!normal)
-				dstContext.globalCompositeOperation = mode;
-			dstContext.drawImage(srcCanvas, offset.x, offset.y);
-			dstContext.restore();
-		} else {
-			var process = modes[mode];
-			if (!process)
-				return;
-			var dstData = dstContext.getImageData(offset.x, offset.y,
-					srcCanvas.width, srcCanvas.height),
-				dst = dstData.data,
-				src = srcContext.getImageData(0, 0,
-					srcCanvas.width, srcCanvas.height).data;
-			for (var i = 0, l = dst.length; i < l; i += 4) {
-				sr = src[i];
-				br = dst[i];
-				sg = src[i + 1];
-				bg = dst[i + 1];
-				sb = src[i + 2];
-				bb = dst[i + 2];
-				sa = src[i + 3];
-				ba = dst[i + 3];
-				process();
-				var a1 = sa * alpha / 255,
-					a2 = 1 - a1;
-				dst[i] = a1 * dr + a2 * br;
-				dst[i + 1] = a1 * dg + a2 * bg;
-				dst[i + 2] = a1 * db + a2 * bb;
-				dst[i + 3] = sa * alpha + a2 * ba;
-			}
-			dstContext.putImageData(dstData, offset.x, offset.y);
-		}
-	};
-};
-
-var SvgElement = new function() {
-	var svg = 'http://www.w3.org/2000/svg',
-		xmlns = 'http://www.w3.org/2000/xmlns',
-		xlink = 'http://www.w3.org/1999/xlink',
-		attributeNamespace = {
-			href: xlink,
-			xlink: xmlns,
-			xmlns: xmlns + '/',
-			'xmlns:xlink': xmlns + '/'
-		};
-
-	function create(tag, attributes, formatter) {
-		return set(document.createElementNS(svg, tag), attributes, formatter);
-	}
-
-	function get(node, name) {
-		var namespace = attributeNamespace[name],
-			value = namespace
-				? node.getAttributeNS(namespace, name)
-				: node.getAttribute(name);
-		return value === 'null' ? null : value;
-	}
-
-	function set(node, attributes, formatter) {
-		for (var name in attributes) {
-			var value = attributes[name],
-				namespace = attributeNamespace[name];
-			if (typeof value === 'number' && formatter)
-				value = formatter.number(value);
-			if (namespace) {
-				node.setAttributeNS(namespace, name, value);
-			} else {
-				node.setAttribute(name, value);
-			}
-		}
-		return node;
-	}
-
-	return {
-		svg: svg,
-		xmlns: xmlns,
-		xlink: xlink,
-
-		create: create,
-		get: get,
-		set: set
-	};
-};
-
-var SvgStyles = Base.each({
-	fillColor: ['fill', 'color'],
-	fillRule: ['fill-rule', 'string'],
-	strokeColor: ['stroke', 'color'],
-	strokeWidth: ['stroke-width', 'number'],
-	strokeCap: ['stroke-linecap', 'string'],
-	strokeJoin: ['stroke-linejoin', 'string'],
-	strokeScaling: ['vector-effect', 'lookup', {
-		true: 'none',
-		false: 'non-scaling-stroke'
-	}, function(item, value) {
-		return !value
-				&& (item instanceof PathItem
-					|| item instanceof Shape
-					|| item instanceof TextItem);
-	}],
-	miterLimit: ['stroke-miterlimit', 'number'],
-	dashArray: ['stroke-dasharray', 'array'],
-	dashOffset: ['stroke-dashoffset', 'number'],
-	fontFamily: ['font-family', 'string'],
-	fontWeight: ['font-weight', 'string'],
-	fontSize: ['font-size', 'number'],
-	justification: ['text-anchor', 'lookup', {
-		left: 'start',
-		center: 'middle',
-		right: 'end'
-	}],
-	opacity: ['opacity', 'number'],
-	blendMode: ['mix-blend-mode', 'style']
-}, function(entry, key) {
-	var part = Base.capitalize(key),
-		lookup = entry[2];
-	this[key] = {
-		type: entry[1],
-		property: key,
-		attribute: entry[0],
-		toSVG: lookup,
-		fromSVG: lookup && Base.each(lookup, function(value, name) {
-			this[value] = name;
-		}, {}),
-		exportFilter: entry[3],
-		get: 'get' + part,
-		set: 'set' + part
-	};
-}, {});
-
-new function() {
-	var formatter;
-
-	function getTransform(matrix, coordinates, center) {
-		var attrs = new Base(),
-			trans = matrix.getTranslation();
-		if (coordinates) {
-			var point;
-			if (matrix.isInvertible()) {
-				matrix = matrix._shiftless();
-				point = matrix._inverseTransform(trans);
-				trans = null;
-			} else {
-				point = new Point();
-			}
-			attrs[center ? 'cx' : 'x'] = point.x;
-			attrs[center ? 'cy' : 'y'] = point.y;
-		}
-		if (!matrix.isIdentity()) {
-			var decomposed = matrix.decompose();
-			if (decomposed) {
-				var parts = [],
-					angle = decomposed.rotation,
-					scale = decomposed.scaling,
-					skew = decomposed.skewing;
-				if (trans && !trans.isZero())
-					parts.push('translate(' + formatter.point(trans) + ')');
-				if (angle)
-					parts.push('rotate(' + formatter.number(angle) + ')');
-				if (!Numerical.isZero(scale.x - 1)
-						|| !Numerical.isZero(scale.y - 1))
-					parts.push('scale(' + formatter.point(scale) +')');
-				if (skew.x)
-					parts.push('skewX(' + formatter.number(skew.x) + ')');
-				if (skew.y)
-					parts.push('skewY(' + formatter.number(skew.y) + ')');
-				attrs.transform = parts.join(' ');
-			} else {
-				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
-			}
-		}
-		return attrs;
-	}
-
-	function exportGroup(item, options) {
-		var attrs = getTransform(item._matrix),
-			children = item._children;
-		var node = SvgElement.create('g', attrs, formatter);
-		for (var i = 0, l = children.length; i < l; i++) {
-			var child = children[i];
-			var childNode = exportSVG(child, options);
-			if (childNode) {
-				if (child.isClipMask()) {
-					var clip = SvgElement.create('clipPath');
-					clip.appendChild(childNode);
-					setDefinition(child, clip, 'clip');
-					SvgElement.set(node, {
-						'clip-path': 'url(#' + clip.id + ')'
-					});
-				} else {
-					node.appendChild(childNode);
-				}
-			}
-		}
-		return node;
-	}
-
-	function exportRaster(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			size = item.getSize(),
-			image = item.getImage();
-		attrs.x -= size.width / 2;
-		attrs.y -= size.height / 2;
-		attrs.width = size.width;
-		attrs.height = size.height;
-		attrs.href = options.embedImages == false && image && image.src
-				|| item.toDataURL();
-		return SvgElement.create('image', attrs, formatter);
-	}
-
-	function exportPath(item, options) {
-		var matchShapes = options.matchShapes;
-		if (matchShapes) {
-			var shape = item.toShape(false);
-			if (shape)
-				return exportShape(shape, options);
-		}
-		var segments = item._segments,
-			length = segments.length,
-			type,
-			attrs = getTransform(item._matrix);
-		if (matchShapes && length >= 2 && !item.hasHandles()) {
-			if (length > 2) {
-				type = item._closed ? 'polygon' : 'polyline';
-				var parts = [];
-				for (var i = 0; i < length; i++) {
-					parts.push(formatter.point(segments[i]._point));
-				}
-				attrs.points = parts.join(' ');
-			} else {
-				type = 'line';
-				var start = segments[0]._point,
-					end = segments[1]._point;
-				attrs.set({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y
-				});
-			}
-		} else {
-			type = 'path';
-			attrs.d = item.getPathData(null, options.precision);
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportShape(item) {
-		var type = item._type,
-			radius = item._radius,
-			attrs = getTransform(item._matrix, true, type !== 'rectangle');
-		if (type === 'rectangle') {
-			type = 'rect';
-			var size = item._size,
-				width = size.width,
-				height = size.height;
-			attrs.x -= width / 2;
-			attrs.y -= height / 2;
-			attrs.width = width;
-			attrs.height = height;
-			if (radius.isZero())
-				radius = null;
-		}
-		if (radius) {
-			if (type === 'circle') {
-				attrs.r = radius;
-			} else {
-				attrs.rx = radius.width;
-				attrs.ry = radius.height;
-			}
-		}
-		return SvgElement.create(type, attrs, formatter);
-	}
-
-	function exportCompoundPath(item, options) {
-		var attrs = getTransform(item._matrix);
-		var data = item.getPathData(null, options.precision);
-		if (data)
-			attrs.d = data;
-		return SvgElement.create('path', attrs, formatter);
-	}
-
-	function exportSymbolItem(item, options) {
-		var attrs = getTransform(item._matrix, true),
-			definition = item._definition,
-			node = getDefinition(definition, 'symbol'),
-			definitionItem = definition._item,
-			bounds = definitionItem.getStrokeBounds();
-		if (!node) {
-			node = SvgElement.create('symbol', {
-				viewBox: formatter.rectangle(bounds)
-			});
-			node.appendChild(exportSVG(definitionItem, options));
-			setDefinition(definition, node, 'symbol');
-		}
-		attrs.href = '#' + node.id;
-		attrs.x += bounds.x;
-		attrs.y += bounds.y;
-		attrs.width = bounds.width;
-		attrs.height = bounds.height;
-		attrs.overflow = 'visible';
-		return SvgElement.create('use', attrs, formatter);
-	}
-
-	function exportGradient(color) {
-		var gradientNode = getDefinition(color, 'color');
-		if (!gradientNode) {
-			var gradient = color.getGradient(),
-				radial = gradient._radial,
-				origin = color.getOrigin(),
-				destination = color.getDestination(),
-				attrs;
-			if (radial) {
-				attrs = {
-					cx: origin.x,
-					cy: origin.y,
-					r: origin.getDistance(destination)
-				};
-				var highlight = color.getHighlight();
-				if (highlight) {
-					attrs.fx = highlight.x;
-					attrs.fy = highlight.y;
-				}
-			} else {
-				attrs = {
-					x1: origin.x,
-					y1: origin.y,
-					x2: destination.x,
-					y2: destination.y
-				};
-			}
-			attrs.gradientUnits = 'userSpaceOnUse';
-			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
-					+ 'Gradient', attrs, formatter);
-			var stops = gradient._stops;
-			for (var i = 0, l = stops.length; i < l; i++) {
-				var stop = stops[i],
-					stopColor = stop._color,
-					alpha = stopColor.getAlpha(),
-					offset = stop._offset;
-				attrs = {
-					offset: offset == null ? i / (l - 1) : offset
-				};
-				if (stopColor)
-					attrs['stop-color'] = stopColor.toCSS(true);
-				if (alpha < 1)
-					attrs['stop-opacity'] = alpha;
-				gradientNode.appendChild(
-						SvgElement.create('stop', attrs, formatter));
-			}
-			setDefinition(color, gradientNode, 'color');
-		}
-		return 'url(#' + gradientNode.id + ')';
-	}
-
-	function exportText(item) {
-		var node = SvgElement.create('text', getTransform(item._matrix, true),
-				formatter);
-		node.textContent = item._content;
-		return node;
-	}
-
-	var exporters = {
-		Group: exportGroup,
-		Layer: exportGroup,
-		Raster: exportRaster,
-		Path: exportPath,
-		Shape: exportShape,
-		CompoundPath: exportCompoundPath,
-		SymbolItem: exportSymbolItem,
-		PointText: exportText
-	};
-
-	function applyStyle(item, node, isRoot) {
-		var attrs = {},
-			parent = !isRoot && item.getParent(),
-			style = [];
-
-		if (item._name != null)
-			attrs.id = item._name;
-
-		Base.each(SvgStyles, function(entry) {
-			var get = entry.get,
-				type = entry.type,
-				value = item[get]();
-			if (entry.exportFilter
-					? entry.exportFilter(item, value)
-					: !parent || !Base.equals(parent[get](), value)) {
-				if (type === 'color' && value != null) {
-					var alpha = value.getAlpha();
-					if (alpha < 1)
-						attrs[entry.attribute + '-opacity'] = alpha;
-				}
-				if (type === 'style') {
-					style.push(entry.attribute + ': ' + value);
-				} else {
-					attrs[entry.attribute] = value == null ? 'none'
-							: type === 'color' ? value.gradient
-								? exportGradient(value, item)
-								: value.toCSS(true)
-							: type === 'array' ? value.join(',')
-							: type === 'lookup' ? entry.toSVG[value]
-							: value;
-				}
-			}
-		});
-
-		if (style.length)
-			attrs.style = style.join(';');
-
-		if (attrs.opacity === 1)
-			delete attrs.opacity;
-
-		if (!item._visible)
-			attrs.visibility = 'hidden';
-
-		return SvgElement.set(node, attrs, formatter);
-	}
-
-	var definitions;
-	function getDefinition(item, type) {
-		if (!definitions)
-			definitions = { ids: {}, svgs: {} };
-		return item && definitions.svgs[type + '-'
-				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
-	}
-
-	function setDefinition(item, node, type) {
-		if (!definitions)
-			getDefinition();
-		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
-		node.id = type + '-' + typeId;
-		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
-	}
-
-	function exportDefinitions(node, options) {
-		var svg = node,
-			defs = null;
-		if (definitions) {
-			svg = node.nodeName.toLowerCase() === 'svg' && node;
-			for (var i in definitions.svgs) {
-				if (!defs) {
-					if (!svg) {
-						svg = SvgElement.create('svg');
-						svg.appendChild(node);
-					}
-					defs = svg.insertBefore(SvgElement.create('defs'),
-							svg.firstChild);
-				}
-				defs.appendChild(definitions.svgs[i]);
-			}
-			definitions = null;
-		}
-		return options.asString
-				? new self.XMLSerializer().serializeToString(svg)
-				: svg;
-	}
-
-	function exportSVG(item, options, isRoot) {
-		var exporter = exporters[item._class],
-			node = exporter && exporter(item, options);
-		if (node) {
-			var onExport = options.onExport;
-			if (onExport)
-				node = onExport(item, node, options) || node;
-			var data = JSON.stringify(item._data);
-			if (data && data !== '{}' && data !== 'null')
-				node.setAttribute('data-paper-data', data);
-		}
-		return node && applyStyle(item, node, isRoot);
-	}
-
-	function setOptions(options) {
-		if (!options)
-			options = {};
-		formatter = new Formatter(options.precision);
-		return options;
-	}
-
-	Item.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			return exportDefinitions(exportSVG(this, options, true), options);
-		}
-	});
-
-	Project.inject({
-		exportSVG: function(options) {
-			options = setOptions(options);
-			var children = this._children,
-				view = this.getView(),
-				bounds = Base.pick(options.bounds, 'view'),
-				mx = options.matrix || bounds === 'view' && view._matrix,
-				matrix = mx && Matrix.read([mx]),
-				rect = bounds === 'view'
-					? new Rectangle([0, 0], view.getViewSize())
-					: bounds === 'content'
-						? Item._getBounds(children, matrix, { stroke: true })
-							.rect
-						: Rectangle.read([bounds], 0, { readNull: true }),
-				attrs = {
-					version: '1.1',
-					xmlns: SvgElement.svg,
-					'xmlns:xlink': SvgElement.xlink,
-				};
-			if (rect) {
-				attrs.width = rect.width;
-				attrs.height = rect.height;
-				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
-					attrs.viewBox = formatter.rectangle(rect);
-			}
-			var node = SvgElement.create('svg', attrs, formatter),
-				parent = node;
-			if (matrix && !matrix.isIdentity()) {
-				parent = node.appendChild(SvgElement.create('g',
-						getTransform(matrix), formatter));
-			}
-			for (var i = 0, l = children.length; i < l; i++) {
-				parent.appendChild(exportSVG(children[i], options, true));
-			}
-			return exportDefinitions(node, options);
-		}
-	});
-};
-
-new function() {
-
-	var definitions = {},
-		rootSize;
-
-	function getValue(node, name, isString, allowNull, allowPercent,
-			defaultValue) {
-		var value = SvgElement.get(node, name) || defaultValue,
-			res = value == null
-				? allowNull
-					? null
-					: isString ? '' : 0
-				: isString
-					? value
-					: parseFloat(value);
-		return /%\s*$/.test(value)
-			? (res / 100) * (allowPercent ? 1
-				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
-			: res;
-	}
-
-	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
-		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
-		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
-		return allowNull && (x == null || y == null) ? null
-				: new Point(x, y);
-	}
-
-	function getSize(node, w, h, allowNull, allowPercent) {
-		w = getValue(node, w || 'width', false, allowNull, allowPercent);
-		h = getValue(node, h || 'height', false, allowNull, allowPercent);
-		return allowNull && (w == null || h == null) ? null
-				: new Size(w, h);
-	}
-
-	function convertValue(value, type, lookup) {
-		return value === 'none' ? null
-				: type === 'number' ? parseFloat(value)
-				: type === 'array' ?
-					value ? value.split(/[\s,]+/g).map(parseFloat) : []
-				: type === 'color' ? getDefinition(value) || value
-				: type === 'lookup' ? lookup[value]
-				: value;
-	}
-
-	function importGroup(node, type, options, isRoot) {
-		var nodes = node.childNodes,
-			isClip = type === 'clippath',
-			isDefs = type === 'defs',
-			item = new Group(),
-			project = item._project,
-			currentStyle = project._currentStyle,
-			children = [];
-		if (!isClip && !isDefs) {
-			item = applyAttributes(item, node, isRoot);
-			project._currentStyle = item._style.clone();
-		}
-		if (isRoot) {
-			var defs = node.querySelectorAll('defs');
-			for (var i = 0, l = defs.length; i < l; i++) {
-				importNode(defs[i], options, false);
-			}
-		}
-		for (var i = 0, l = nodes.length; i < l; i++) {
-			var childNode = nodes[i],
-				child;
-			if (childNode.nodeType === 1
-					&& !/^defs$/i.test(childNode.nodeName)
-					&& (child = importNode(childNode, options, false))
-					&& !(child instanceof SymbolDefinition))
-				children.push(child);
-		}
-		item.addChildren(children);
-		if (isClip)
-			item = applyAttributes(item.reduce(), node, isRoot);
-		project._currentStyle = currentStyle;
-		if (isClip || isDefs) {
-			item.remove();
-			item = null;
-		}
-		return item;
-	}
-
-	function importPoly(node, type) {
-		var coords = node.getAttribute('points').match(
-					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
-			points = [];
-		for (var i = 0, l = coords.length; i < l; i += 2)
-			points.push(new Point(
-					parseFloat(coords[i]),
-					parseFloat(coords[i + 1])));
-		var path = new Path(points);
-		if (type === 'polygon')
-			path.closePath();
-		return path;
-	}
-
-	function importPath(node) {
-		return PathItem.create(node.getAttribute('d'));
-	}
-
-	function importGradient(node, type) {
-		var id = (getValue(node, 'href', true) || '').substring(1),
-			radial = type === 'radialgradient',
-			gradient;
-		if (id) {
-			gradient = definitions[id].getGradient();
-			if (gradient._radial ^ radial) {
-				gradient = gradient.clone();
-				gradient._radial = radial;
-			}
-		} else {
-			var nodes = node.childNodes,
-				stops = [];
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					stops.push(applyAttributes(new GradientStop(), child));
-			}
-			gradient = new Gradient(stops, radial);
-		}
-		var origin, destination, highlight,
-			scaleToBounds = getValue(node, 'gradientUnits', true) !==
-				'userSpaceOnUse';
-		if (radial) {
-			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
-				'50%', '50%');
-			destination = origin.add(
-				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
-			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
-		} else {
-			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
-				'0%', '0%');
-			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
-				'100%', '0%');
-		}
-		var color = applyAttributes(
-				new Color(gradient, origin, destination, highlight), node);
-		color._scaleToBounds = scaleToBounds;
-		return null;
-	}
-
-	var importers = {
-		'#document': function (node, type, options, isRoot) {
-			var nodes = node.childNodes;
-			for (var i = 0, l = nodes.length; i < l; i++) {
-				var child = nodes[i];
-				if (child.nodeType === 1)
-					return importNode(child, options, isRoot);
-			}
-		},
-		g: importGroup,
-		svg: importGroup,
-		clippath: importGroup,
-		polygon: importPoly,
-		polyline: importPoly,
-		path: importPath,
-		lineargradient: importGradient,
-		radialgradient: importGradient,
-
-		image: function (node) {
-			var raster = new Raster(getValue(node, 'href', true));
-			raster.on('load', function() {
-				var size = getSize(node);
-				this.setSize(size);
-				var center = getPoint(node).add(size.divide(2));
-				this._matrix.append(new Matrix().translate(center));
-			});
-			return raster;
-		},
-
-		symbol: function(node, type, options, isRoot) {
-			return new SymbolDefinition(
-					importGroup(node, type, options, isRoot), true);
-		},
-
-		defs: importGroup,
-
-		use: function(node) {
-			var id = (getValue(node, 'href', true) || '').substring(1),
-				definition = definitions[id],
-				point = getPoint(node);
-			return definition
-					? definition instanceof SymbolDefinition
-						? definition.place(point)
-						: definition.clone().translate(point)
-					: null;
-		},
-
-		circle: function(node) {
-			return new Shape.Circle(
-					getPoint(node, 'cx', 'cy'),
-					getValue(node, 'r'));
-		},
-
-		ellipse: function(node) {
-			return new Shape.Ellipse({
-				center: getPoint(node, 'cx', 'cy'),
-				radius: getSize(node, 'rx', 'ry')
-			});
-		},
-
-		rect: function(node) {
-			return new Shape.Rectangle(new Rectangle(
-						getPoint(node),
-						getSize(node)
-					), getSize(node, 'rx', 'ry'));
-			},
-
-		line: function(node) {
-			return new Path.Line(
-					getPoint(node, 'x1', 'y1'),
-					getPoint(node, 'x2', 'y2'));
-		},
-
-		text: function(node) {
-			var text = new PointText(getPoint(node).add(
-					getPoint(node, 'dx', 'dy')));
-			text.setContent(node.textContent.trim() || '');
-			return text;
-		},
-
-		switch: importGroup
-	};
-
-	function applyTransform(item, value, name, node) {
-		if (item.transform) {
-			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
-				matrix = new Matrix();
-			for (var i = 0, l = transforms.length; i < l; i++) {
-				var transform = transforms[i];
-				if (!transform)
-					break;
-				var parts = transform.split(/\(\s*/),
-					command = parts[0],
-					v = parts[1].split(/[\s,]+/g);
-				for (var j = 0, m = v.length; j < m; j++)
-					v[j] = parseFloat(v[j]);
-				switch (command) {
-				case 'matrix':
-					matrix.append(
-							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
-					break;
-				case 'rotate':
-					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
-					break;
-				case 'translate':
-					matrix.translate(v[0], v[1] || 0);
-					break;
-				case 'scale':
-					matrix.scale(v);
-					break;
-				case 'skewX':
-					matrix.skew(v[0], 0);
-					break;
-				case 'skewY':
-					matrix.skew(0, v[0]);
-					break;
-				}
-			}
-			item.transform(matrix);
-		}
-	}
-
-	function applyOpacity(item, value, name) {
-		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
-			color = item[key] && item[key]();
-		if (color)
-			color.setAlpha(parseFloat(value));
-	}
-
-	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
-		this[entry.attribute] = function(item, value) {
-			if (item[entry.set]) {
-				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
-				if (entry.type === 'color') {
-					var color = item[entry.get]();
-					if (color) {
-						if (color._scaleToBounds) {
-							var bounds = item.getBounds();
-							color.transform(new Matrix()
-								.translate(bounds.getPoint())
-								.scale(bounds.getSize()));
-						}
-					}
-				}
-			}
-		};
-	}, {}), {
-		id: function(item, value) {
-			definitions[value] = item;
-			if (item.setName)
-				item.setName(value);
-		},
-
-		'clip-path': function(item, value) {
-			var clip = getDefinition(value);
-			if (clip) {
-				clip = clip.clone();
-				clip.setClipMask(true);
-				if (item instanceof Group) {
-					item.insertChild(0, clip);
-				} else {
-					return new Group(clip, item);
-				}
-			}
-		},
-
-		gradientTransform: applyTransform,
-		transform: applyTransform,
-
-		'fill-opacity': applyOpacity,
-		'stroke-opacity': applyOpacity,
-
-		visibility: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value === 'visible');
-		},
-
-		display: function(item, value) {
-			if (item.setVisible)
-				item.setVisible(value !== null);
-		},
-
-		'stop-color': function(item, value) {
-			if (item.setColor)
-				item.setColor(value);
-		},
-
-		'stop-opacity': function(item, value) {
-			if (item._color)
-				item._color.setAlpha(parseFloat(value));
-		},
-
-		offset: function(item, value) {
-			if (item.setOffset) {
-				var percent = value.match(/(.*)%$/);
-				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
-			}
-		},
-
-		viewBox: function(item, value, name, node, styles) {
-			var rect = new Rectangle(convertValue(value, 'array')),
-				size = getSize(node, null, null, true),
-				group,
-				matrix;
-			if (item instanceof Group) {
-				var scale = size ? size.divide(rect.getSize()) : 1,
-				matrix = new Matrix().scale(scale)
-						.translate(rect.getPoint().negate());
-				group = item;
-			} else if (item instanceof SymbolDefinition) {
-				if (size)
-					rect.setSize(size);
-				group = item._item;
-			}
-			if (group)  {
-				if (getAttribute(node, 'overflow', styles) !== 'visible') {
-					var clip = new Shape.Rectangle(rect);
-					clip.setClipMask(true);
-					group.addChild(clip);
-				}
-				if (matrix)
-					group.transform(matrix);
-			}
-		}
-	});
-
-	function getAttribute(node, name, styles) {
-		var attr = node.attributes[name],
-			value = attr && attr.value;
-		if (!value && node.style) {
-			var style = Base.camelize(name);
-			value = node.style[style];
-			if (!value && styles.node[style] !== styles.parent[style])
-				value = styles.node[style];
-		}
-		return !value ? undefined
-				: value === 'none' ? null
-				: value;
-	}
-
-	function applyAttributes(item, node, isRoot) {
-		var parent = node.parentNode,
-			styles = {
-				node: DomElement.getStyles(node) || {},
-				parent: !isRoot && !/^defs$/i.test(parent.tagName)
-						&& DomElement.getStyles(parent) || {}
-			};
-		Base.each(attributes, function(apply, name) {
-			var value = getAttribute(node, name, styles);
-			item = value !== undefined
-					&& apply(item, value, name, node, styles) || item;
-		});
-		return item;
-	}
-
-	function getDefinition(value) {
-		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
-			name = match && match[1],
-			res = name && definitions[window
-					? name.replace(window.location.href.split('#')[0] + '#', '')
-					: name];
-		if (res && res._scaleToBounds) {
-			res = res.clone();
-			res._scaleToBounds = true;
-		}
-		return res;
-	}
-
-	function importNode(node, options, isRoot) {
-		var type = node.nodeName.toLowerCase(),
-			isElement = type !== '#document',
-			body = document.body,
-			container,
-			parent,
-			next;
-		if (isRoot && isElement) {
-			rootSize = paper.getView().getSize();
-			rootSize = getSize(node, null, null, true) || rootSize;
-			container = SvgElement.create('svg', {
-				style: 'stroke-width: 1px; stroke-miterlimit: 10'
-			});
-			parent = node.parentNode;
-			next = node.nextSibling;
-			container.appendChild(node);
-			body.appendChild(container);
-		}
-		var settings = paper.settings,
-			applyMatrix = settings.applyMatrix,
-			insertItems = settings.insertItems;
-		settings.applyMatrix = false;
-		settings.insertItems = false;
-		var importer = importers[type],
-			item = importer && importer(node, type, options, isRoot) || null;
-		settings.insertItems = insertItems;
-		settings.applyMatrix = applyMatrix;
-		if (item) {
-			if (isElement && !(item instanceof Group))
-				item = applyAttributes(item, node, isRoot);
-			var onImport = options.onImport,
-				data = isElement && node.getAttribute('data-paper-data');
-			if (onImport)
-				item = onImport(node, item, options) || item;
-			if (options.expandShapes && item instanceof Shape) {
-				item.remove();
-				item = item.toPath();
-			}
-			if (data)
-				item._data = JSON.parse(data);
-		}
-		if (container) {
-			body.removeChild(container);
-			if (parent) {
-				if (next) {
-					parent.insertBefore(node, next);
-				} else {
-					parent.appendChild(node);
-				}
-			}
-		}
-		if (isRoot) {
-			definitions = {};
-			if (item && Base.pick(options.applyMatrix, applyMatrix))
-				item.matrix.apply(true, true);
-		}
-		return item;
-	}
-
-	function importSVG(source, options, owner) {
-		if (!source)
-			return null;
-		options = typeof options === 'function' ? { onLoad: options }
-				: options || {};
-		var scope = paper,
-			item = null;
-
-		function onLoad(svg) {
-			try {
-				var node = typeof svg === 'object'
-					? svg
-					: new self.DOMParser().parseFromString(
-						svg,
-						'image/svg+xml'
-					);
-				if (!node.nodeName) {
-					node = null;
-					throw new Error('Unsupported SVG source: ' + source);
-				}
-				paper = scope;
-				item = importNode(node, options, true);
-				if (!options || options.insert !== false) {
-					owner._insertItem(undefined, item);
-				}
-				var onLoad = options.onLoad;
-				if (onLoad)
-					onLoad(item, svg);
-			} catch (e) {
-				onError(e);
-			}
-		}
-
-		function onError(message, status) {
-			var onError = options.onError;
-			if (onError) {
-				onError(message, status);
-			} else {
-				throw new Error(message);
-			}
-		}
-
-		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
-			var node = document.getElementById(source);
-			if (node) {
-				onLoad(node);
-			} else {
-				Http.request({
-					url: source,
-					async: true,
-					onLoad: onLoad,
-					onError: onError
-				});
-			}
-		} else if (typeof File !== 'undefined' && source instanceof File) {
-			var reader = new FileReader();
-			reader.onload = function() {
-				onLoad(reader.result);
-			};
-			reader.onerror = function() {
-				onError(reader.error);
-			};
-			return reader.readAsText(source);
-		} else {
-			onLoad(source);
-		}
-
-		return item;
-	}
-
-	Item.inject({
-		importSVG: function(node, options) {
-			return importSVG(node, options, this);
-		}
-	});
-
-	Project.inject({
-		importSVG: function(node, options) {
-			this.activate();
-			return importSVG(node, options, this);
-		}
-	});
-};
-
-Base.exports.PaperScript = function() {
-	var global = this,
-		acorn = global.acorn;
-	if (!acorn && typeof require !== 'undefined') {
-		try { acorn = require('acorn'); } catch(e) {}
-	}
-	if (!acorn) {
-		var exports, module;
-		acorn = exports = module = {};
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports);
-  if (typeof define == "function" && define.amd) return define(["exports"], mod);
-  mod(root.acorn || (root.acorn = {}));
-})(this, function(exports) {
-  "use strict";
-
-  exports.version = "0.5.0";
-
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-	return parseTopLevel(options.program);
-  };
-
-  var defaultOptions = exports.defaultOptions = {
-	ecmaVersion: 5,
-	strictSemicolons: false,
-	allowTrailingCommas: true,
-	forbidReserved: false,
-	allowReturnOutsideFunction: false,
-	locations: false,
-	onComment: null,
-	ranges: false,
-	program: null,
-	sourceFile: null,
-	directSourceFile: null
-  };
-
-  function setOptions(opts) {
-	options = opts || {};
-	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
-	  options[opt] = defaultOptions[opt];
-	sourceFile = options.sourceFile || null;
-  }
-
-  var getLineInfo = exports.getLineInfo = function(input, offset) {
-	for (var line = 1, cur = 0;;) {
-	  lineBreak.lastIndex = cur;
-	  var match = lineBreak.exec(input);
-	  if (match && match.index < offset) {
-		++line;
-		cur = match.index + match[0].length;
-	  } else break;
-	}
-	return {line: line, column: offset - cur};
-  };
-
-  exports.tokenize = function(inpt, opts) {
-	input = String(inpt); inputLen = input.length;
-	setOptions(opts);
-	initTokenState();
-
-	var t = {};
-	function getToken(forceRegexp) {
-	  lastEnd = tokEnd;
-	  readToken(forceRegexp);
-	  t.start = tokStart; t.end = tokEnd;
-	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
-	  t.type = tokType; t.value = tokVal;
-	  return t;
-	}
-	getToken.jumpTo = function(pos, reAllowed) {
-	  tokPos = pos;
-	  if (options.locations) {
-		tokCurLine = 1;
-		tokLineStart = lineBreak.lastIndex = 0;
-		var match;
-		while ((match = lineBreak.exec(input)) && match.index < pos) {
-		  ++tokCurLine;
-		  tokLineStart = match.index + match[0].length;
-		}
-	  }
-	  tokRegexpAllowed = reAllowed;
-	  skipSpace();
-	};
-	return getToken;
-  };
-
-  var tokPos;
-
-  var tokStart, tokEnd;
-
-  var tokStartLoc, tokEndLoc;
-
-  var tokType, tokVal;
-
-  var tokRegexpAllowed;
-
-  var tokCurLine, tokLineStart;
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  var inFunction, labels, strict;
-
-  function raise(pos, message) {
-	var loc = getLineInfo(input, pos);
-	message += " (" + loc.line + ":" + loc.column + ")";
-	var err = new SyntaxError(message);
-	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-	throw err;
-  }
-
-  var empty = [];
-
-  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
-
-  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
-  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
-  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
-  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
-  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
-  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
-  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};
-
-  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
-
-  var _in = {keyword: "in", binop: 7, beforeExpr: true};
-
-  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
-					  "continue": _continue, "debugger": _debugger, "default": _default,
-					  "do": _do, "else": _else, "finally": _finally, "for": _for,
-					  "function": _function, "if": _if, "return": _return, "switch": _switch,
-					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
-					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
-					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
-					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
-					  "void": {keyword: "void", prefix: true, beforeExpr: true},
-					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
-
-  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
-  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
-  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
-
-  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
-  var _assign = {isAssign: true, beforeExpr: true};
-  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
-  var _logicalOR = {binop: 1, beforeExpr: true};
-  var _logicalAND = {binop: 2, beforeExpr: true};
-  var _bitwiseOR = {binop: 3, beforeExpr: true};
-  var _bitwiseXOR = {binop: 4, beforeExpr: true};
-  var _bitwiseAND = {binop: 5, beforeExpr: true};
-  var _equality = {binop: 6, beforeExpr: true};
-  var _relational = {binop: 7, beforeExpr: true};
-  var _bitShift = {binop: 8, beforeExpr: true};
-  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};
-
-  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
-					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
-					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
-					  num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
-
-  function makePredicate(words) {
-	words = words.split(" ");
-	var f = "", cats = [];
-	out: for (var i = 0; i < words.length; ++i) {
-	  for (var j = 0; j < cats.length; ++j)
-		if (cats[j][0].length == words[i].length) {
-		  cats[j].push(words[i]);
-		  continue out;
-		}
-	  cats.push([words[i]]);
-	}
-	function compareTo(arr) {
-	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
-	  f += "switch(str){";
-	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
-	  f += "return true}return false;";
-	}
-
-	if (cats.length > 3) {
-	  cats.sort(function(a, b) {return b.length - a.length;});
-	  f += "switch(str.length){";
-	  for (var i = 0; i < cats.length; ++i) {
-		var cat = cats[i];
-		f += "case " + cat[0].length + ":";
-		compareTo(cat);
-	  }
-	  f += "}";
-
-	} else {
-	  compareTo(words);
-	}
-	return new Function("str", f);
-  }
-
-  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
-
-  var isReservedWord5 = makePredicate("class enum extends super const export import");
-
-  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
-
-  var isStrictBadIdWord = makePredicate("eval arguments");
-
-  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
-
-  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
-  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
-
-  var isIdentifierStart = exports.isIdentifierStart = function(code) {
-	if (code < 65) return code === 36;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
-
-  var isIdentifierChar = exports.isIdentifierChar = function(code) {
-	if (code < 48) return code === 36;
-	if (code < 58) return true;
-	if (code < 65) return false;
-	if (code < 91) return true;
-	if (code < 97) return code === 95;
-	if (code < 123)return true;
-	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
-
-  function line_loc_t() {
-	this.line = tokCurLine;
-	this.column = tokPos - tokLineStart;
-  }
-
-  function initTokenState() {
-	tokCurLine = 1;
-	tokPos = tokLineStart = 0;
-	tokRegexpAllowed = true;
-	skipSpace();
-  }
-
-  function finishToken(type, val) {
-	tokEnd = tokPos;
-	if (options.locations) tokEndLoc = new line_loc_t;
-	tokType = type;
-	skipSpace();
-	tokVal = val;
-	tokRegexpAllowed = type.beforeExpr;
-  }
-
-  function skipBlockComment() {
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-	if (end === -1) raise(tokPos - 2, "Unterminated comment");
-	tokPos = end + 2;
-	if (options.locations) {
-	  lineBreak.lastIndex = start;
-	  var match;
-	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-		++tokCurLine;
-		tokLineStart = match.index + match[0].length;
-	  }
-	}
-	if (options.onComment)
-	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipLineComment() {
-	var start = tokPos;
-	var startLoc = options.onComment && options.locations && new line_loc_t;
-	var ch = input.charCodeAt(tokPos+=2);
-	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-	  ++tokPos;
-	  ch = input.charCodeAt(tokPos);
-	}
-	if (options.onComment)
-	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
-						startLoc, options.locations && new line_loc_t);
-  }
-
-  function skipSpace() {
-	while (tokPos < inputLen) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === 32) {
-		++tokPos;
-	  } else if (ch === 13) {
-		++tokPos;
-		var next = input.charCodeAt(tokPos);
-		if (next === 10) {
-		  ++tokPos;
-		}
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
-		++tokPos;
-		if (options.locations) {
-		  ++tokCurLine;
-		  tokLineStart = tokPos;
-		}
-	  } else if (ch > 8 && ch < 14) {
-		++tokPos;
-	  } else if (ch === 47) {
-		var next = input.charCodeAt(tokPos + 1);
-		if (next === 42) {
-		  skipBlockComment();
-		} else if (next === 47) {
-		  skipLineComment();
-		} else break;
-	  } else if (ch === 160) {
-		++tokPos;
-	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-		++tokPos;
-	  } else {
-		break;
-	  }
-	}
-  }
-
-  function readToken_dot() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next >= 48 && next <= 57) return readNumber(true);
-	++tokPos;
-	return finishToken(_dot);
-  }
-
-  function readToken_slash() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_multiplyModulo, 1);
-  }
-
-  function readToken_pipe_amp(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === code) {
-	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-		  newline.test(input.slice(lastEnd, tokPos))) {
-		tokPos += 3;
-		skipLineComment();
-		skipSpace();
-		return readToken();
-	  }
-	  return finishOp(_incDec, 2);
-	}
-	if (next === 61) return finishOp(_assign, 2);
-	return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	var size = 1;
-	if (next === code) {
-	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-	  return finishOp(_bitShift, size);
-	}
-	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-		input.charCodeAt(tokPos + 3) == 45) {
-	  tokPos += 4;
-	  skipLineComment();
-	  skipSpace();
-	  return readToken();
-	}
-	if (next === 61)
-	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-	return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) {
-	var next = input.charCodeAt(tokPos + 1);
-	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-	return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-	switch(code) {
-	case 46:
-	  return readToken_dot();
-
-	case 40: ++tokPos; return finishToken(_parenL);
-	case 41: ++tokPos; return finishToken(_parenR);
-	case 59: ++tokPos; return finishToken(_semi);
-	case 44: ++tokPos; return finishToken(_comma);
-	case 91: ++tokPos; return finishToken(_bracketL);
-	case 93: ++tokPos; return finishToken(_bracketR);
-	case 123: ++tokPos; return finishToken(_braceL);
-	case 125: ++tokPos; return finishToken(_braceR);
-	case 58: ++tokPos; return finishToken(_colon);
-	case 63: ++tokPos; return finishToken(_question);
-
-	case 48:
-	  var next = input.charCodeAt(tokPos + 1);
-	  if (next === 120 || next === 88) return readHexNumber();
-	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
-	  return readNumber(false);
-
-	case 34: case 39:
-	  return readString(code);
-
-	case 47:
-	  return readToken_slash(code);
-
-	case 37: case 42:
-	  return readToken_mult_modulo();
-
-	case 124: case 38:
-	  return readToken_pipe_amp(code);
-
-	case 94:
-	  return readToken_caret();
-
-	case 43: case 45:
-	  return readToken_plus_min(code);
-
-	case 60: case 62:
-	  return readToken_lt_gt(code);
-
-	case 61: case 33:
-	  return readToken_eq_excl(code);
-
-	case 126:
-	  return finishOp(_prefix, 1);
-	}
-
-	return false;
-  }
-
-  function readToken(forceRegexp) {
-	if (!forceRegexp) tokStart = tokPos;
-	else tokPos = tokStart + 1;
-	if (options.locations) tokStartLoc = new line_loc_t;
-	if (forceRegexp) return readRegexp();
-	if (tokPos >= inputLen) return finishToken(_eof);
-
-	var code = input.charCodeAt(tokPos);
-	if (isIdentifierStart(code) || code === 92 ) return readWord();
-
-	var tok = getTokenFromCode(code);
-
-	if (tok === false) {
-	  var ch = String.fromCharCode(code);
-	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
-	  raise(tokPos, "Unexpected character '" + ch + "'");
-	}
-	return tok;
-  }
-
-  function finishOp(type, size) {
-	var str = input.slice(tokPos, tokPos + size);
-	tokPos += size;
-	finishToken(type, str);
-  }
-
-  function readRegexp() {
-	var content = "", escaped, inClass, start = tokPos;
-	for (;;) {
-	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-	  var ch = input.charAt(tokPos);
-	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
-	  if (!escaped) {
-		if (ch === "[") inClass = true;
-		else if (ch === "]" && inClass) inClass = false;
-		else if (ch === "/" && !inClass) break;
-		escaped = ch === "\\";
-	  } else escaped = false;
-	  ++tokPos;
-	}
-	var content = input.slice(start, tokPos);
-	++tokPos;
-	var mods = readWord1();
-	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
-	try {
-	  var value = new RegExp(content, mods);
-	} catch (e) {
-	  if (e instanceof SyntaxError) raise(start, e.message);
-	  raise(e);
-	}
-	return finishToken(_regexp, value);
-  }
-
-  function readInt(radix, len) {
-	var start = tokPos, total = 0;
-	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	  var code = input.charCodeAt(tokPos), val;
-	  if (code >= 97) val = code - 97 + 10;
-	  else if (code >= 65) val = code - 65 + 10;
-	  else if (code >= 48 && code <= 57) val = code - 48;
-	  else val = Infinity;
-	  if (val >= radix) break;
-	  ++tokPos;
-	  total = total * radix + val;
-	}
-	if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-	return total;
-  }
-
-  function readHexNumber() {
-	tokPos += 2;
-	var val = readInt(16);
-	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-	return finishToken(_num, val);
-  }
-
-  function readNumber(startsWithDot) {
-	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-	if (input.charCodeAt(tokPos) === 46) {
-	  ++tokPos;
-	  readInt(10);
-	  isFloat = true;
-	}
-	var next = input.charCodeAt(tokPos);
-	if (next === 69 || next === 101) {
-	  next = input.charCodeAt(++tokPos);
-	  if (next === 43 || next === 45) ++tokPos;
-	  if (readInt(10) === null) raise(start, "Invalid number");
-	  isFloat = true;
-	}
-	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
-
-	var str = input.slice(start, tokPos), val;
-	if (isFloat) val = parseFloat(str);
-	else if (!octal || str.length === 1) val = parseInt(str, 10);
-	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-	else val = parseInt(str, 8);
-	return finishToken(_num, val);
-  }
-
-  function readString(quote) {
-	tokPos++;
-	var out = "";
-	for (;;) {
-	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-	  var ch = input.charCodeAt(tokPos);
-	  if (ch === quote) {
-		++tokPos;
-		return finishToken(_string, out);
-	  }
-	  if (ch === 92) {
-		ch = input.charCodeAt(++tokPos);
-		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-		if (octal) octal = octal[0];
-		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-		if (octal === "0") octal = null;
-		++tokPos;
-		if (octal) {
-		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-		  out += String.fromCharCode(parseInt(octal, 8));
-		  tokPos += octal.length - 1;
-		} else {
-		  switch (ch) {
-		  case 110: out += "\n"; break;
-		  case 114: out += "\r"; break;
-		  case 120: out += String.fromCharCode(readHexChar(2)); break;
-		  case 117: out += String.fromCharCode(readHexChar(4)); break;
-		  case 85: out += String.fromCharCode(readHexChar(8)); break;
-		  case 116: out += "\t"; break;
-		  case 98: out += "\b"; break;
-		  case 118: out += "\u000b"; break;
-		  case 102: out += "\f"; break;
-		  case 48: out += "\0"; break;
-		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
-		  case 10:
-			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-			break;
-		  default: out += String.fromCharCode(ch); break;
-		  }
-		}
-	  } else {
-		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
-		out += String.fromCharCode(ch);
-		++tokPos;
-	  }
-	}
-  }
-
-  function readHexChar(len) {
-	var n = readInt(16, len);
-	if (n === null) raise(tokStart, "Bad character escape sequence");
-	return n;
-  }
-
-  var containsEsc;
-
-  function readWord1() {
-	containsEsc = false;
-	var word, first = true, start = tokPos;
-	for (;;) {
-	  var ch = input.charCodeAt(tokPos);
-	  if (isIdentifierChar(ch)) {
-		if (containsEsc) word += input.charAt(tokPos);
-		++tokPos;
-	  } else if (ch === 92) {
-		if (!containsEsc) word = input.slice(start, tokPos);
-		containsEsc = true;
-		if (input.charCodeAt(++tokPos) != 117)
-		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-		++tokPos;
-		var esc = readHexChar(4);
-		var escStr = String.fromCharCode(esc);
-		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
-		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
-		  raise(tokPos - 4, "Invalid Unicode escape");
-		word += escStr;
-	  } else {
-		break;
-	  }
-	  first = false;
-	}
-	return containsEsc ? word : input.slice(start, tokPos);
-  }
-
-  function readWord() {
-	var word = readWord1();
-	var type = _name;
-	if (!containsEsc && isKeyword(word))
-	  type = keywordTypes[word];
-	return finishToken(type, word);
-  }
-
-  function next() {
-	lastStart = tokStart;
-	lastEnd = tokEnd;
-	lastEndLoc = tokEndLoc;
-	readToken();
-  }
-
-  function setStrict(strct) {
-	strict = strct;
-	tokPos = tokStart;
-	if (options.locations) {
-	  while (tokPos < tokLineStart) {
-		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-		--tokCurLine;
-	  }
-	}
-	skipSpace();
-	readToken();
-  }
-
-  function node_t() {
-	this.type = null;
-	this.start = tokStart;
-	this.end = null;
-  }
-
-  function node_loc_t() {
-	this.start = tokStartLoc;
-	this.end = null;
-	if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-	var node = new node_t();
-	if (options.locations)
-	  node.loc = new node_loc_t();
-	if (options.directSourceFile)
-	  node.sourceFile = options.directSourceFile;
-	if (options.ranges)
-	  node.range = [tokStart, 0];
-	return node;
-  }
-
-  function startNodeFrom(other) {
-	var node = new node_t();
-	node.start = other.start;
-	if (options.locations) {
-	  node.loc = new node_loc_t();
-	  node.loc.start = other.loc.start;
-	}
-	if (options.ranges)
-	  node.range = [other.range[0], 0];
-
-	return node;
-  }
-
-  function finishNode(node, type) {
-	node.type = type;
-	node.end = lastEnd;
-	if (options.locations)
-	  node.loc.end = lastEndLoc;
-	if (options.ranges)
-	  node.range[1] = lastEnd;
-	return node;
-  }
-
-  function isUseStrict(stmt) {
-	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
-	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
-
-  function eat(type) {
-	if (tokType === type) {
-	  next();
-	  return true;
-	}
-  }
-
-  function canInsertSemicolon() {
-	return !options.strictSemicolons &&
-	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
-
-  function semicolon() {
-	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
-
-  function expect(type) {
-	if (tokType === type) next();
-	else unexpected();
-  }
-
-  function unexpected() {
-	raise(tokStart, "Unexpected token");
-  }
-
-  function checkLVal(expr) {
-	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-	  raise(expr.start, "Assigning to rvalue");
-	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
-
-  function parseTopLevel(program) {
-	lastStart = lastEnd = tokPos;
-	if (options.locations) lastEndLoc = new line_loc_t;
-	inFunction = strict = null;
-	labels = [];
-	readToken();
-
-	var node = program || startNode(), first = true;
-	if (!program) node.body = [];
-	while (tokType !== _eof) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && isUseStrict(stmt)) setStrict(true);
-	  first = false;
-	}
-	return finishNode(node, "Program");
-  }
-
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
-
-  function parseStatement() {
-	if (tokType === _slash || tokType === _assign && tokVal == "/=")
-	  readToken(true);
-
-	var starttype = tokType, node = startNode();
-
-	switch (starttype) {
-	case _break: case _continue:
-	  next();
-	  var isBreak = starttype === _break;
-	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
-	  else if (tokType !== _name) unexpected();
-	  else {
-		node.label = parseIdent();
-		semicolon();
-	  }
-
-	  for (var i = 0; i < labels.length; ++i) {
-		var lab = labels[i];
-		if (node.label == null || lab.name === node.label.name) {
-		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
-		  if (node.label && isBreak) break;
-		}
-	  }
-	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
-	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-	case _debugger:
-	  next();
-	  semicolon();
-	  return finishNode(node, "DebuggerStatement");
-
-	case _do:
-	  next();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  expect(_while);
-	  node.test = parseParenExpression();
-	  semicolon();
-	  return finishNode(node, "DoWhileStatement");
-
-	case _for:
-	  next();
-	  labels.push(loopLabel);
-	  expect(_parenL);
-	  if (tokType === _semi) return parseFor(node, null);
-	  if (tokType === _var) {
-		var init = startNode();
-		next();
-		parseVar(init, true);
-		finishNode(init, "VariableDeclaration");
-		if (init.declarations.length === 1 && eat(_in))
-		  return parseForIn(node, init);
-		return parseFor(node, init);
-	  }
-	  var init = parseExpression(false, true);
-	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
-	  return parseFor(node, init);
-
-	case _function:
-	  next();
-	  return parseFunction(node, true);
-
-	case _if:
-	  next();
-	  node.test = parseParenExpression();
-	  node.consequent = parseStatement();
-	  node.alternate = eat(_else) ? parseStatement() : null;
-	  return finishNode(node, "IfStatement");
-
-	case _return:
-	  if (!inFunction && !options.allowReturnOutsideFunction)
-		raise(tokStart, "'return' outside of function");
-	  next();
-
-	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-	  else { node.argument = parseExpression(); semicolon(); }
-	  return finishNode(node, "ReturnStatement");
-
-	case _switch:
-	  next();
-	  node.discriminant = parseParenExpression();
-	  node.cases = [];
-	  expect(_braceL);
-	  labels.push(switchLabel);
-
-	  for (var cur, sawDefault; tokType != _braceR;) {
-		if (tokType === _case || tokType === _default) {
-		  var isCase = tokType === _case;
-		  if (cur) finishNode(cur, "SwitchCase");
-		  node.cases.push(cur = startNode());
-		  cur.consequent = [];
-		  next();
-		  if (isCase) cur.test = parseExpression();
-		  else {
-			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
-			cur.test = null;
-		  }
-		  expect(_colon);
-		} else {
-		  if (!cur) unexpected();
-		  cur.consequent.push(parseStatement());
-		}
-	  }
-	  if (cur) finishNode(cur, "SwitchCase");
-	  next();
-	  labels.pop();
-	  return finishNode(node, "SwitchStatement");
-
-	case _throw:
-	  next();
-	  if (newline.test(input.slice(lastEnd, tokStart)))
-		raise(lastEnd, "Illegal newline after throw");
-	  node.argument = parseExpression();
-	  semicolon();
-	  return finishNode(node, "ThrowStatement");
-
-	case _try:
-	  next();
-	  node.block = parseBlock();
-	  node.handler = null;
-	  if (tokType === _catch) {
-		var clause = startNode();
-		next();
-		expect(_parenL);
-		clause.param = parseIdent();
-		if (strict && isStrictBadIdWord(clause.param.name))
-		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
-		expect(_parenR);
-		clause.guard = null;
-		clause.body = parseBlock();
-		node.handler = finishNode(clause, "CatchClause");
-	  }
-	  node.guardedHandlers = empty;
-	  node.finalizer = eat(_finally) ? parseBlock() : null;
-	  if (!node.handler && !node.finalizer)
-		raise(node.start, "Missing catch or finally clause");
-	  return finishNode(node, "TryStatement");
-
-	case _var:
-	  next();
-	  parseVar(node);
-	  semicolon();
-	  return finishNode(node, "VariableDeclaration");
-
-	case _while:
-	  next();
-	  node.test = parseParenExpression();
-	  labels.push(loopLabel);
-	  node.body = parseStatement();
-	  labels.pop();
-	  return finishNode(node, "WhileStatement");
-
-	case _with:
-	  if (strict) raise(tokStart, "'with' in strict mode");
-	  next();
-	  node.object = parseParenExpression();
-	  node.body = parseStatement();
-	  return finishNode(node, "WithStatement");
-
-	case _braceL:
-	  return parseBlock();
-
-	case _semi:
-	  next();
-	  return finishNode(node, "EmptyStatement");
-
-	default:
-	  var maybeName = tokVal, expr = parseExpression();
-	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
-		for (var i = 0; i < labels.length; ++i)
-		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-		labels.push({name: maybeName, kind: kind});
-		node.body = parseStatement();
-		labels.pop();
-		node.label = expr;
-		return finishNode(node, "LabeledStatement");
-	  } else {
-		node.expression = expr;
-		semicolon();
-		return finishNode(node, "ExpressionStatement");
-	  }
-	}
-  }
-
-  function parseParenExpression() {
-	expect(_parenL);
-	var val = parseExpression();
-	expect(_parenR);
-	return val;
-  }
-
-  function parseBlock(allowStrict) {
-	var node = startNode(), first = true, strict = false, oldStrict;
-	node.body = [];
-	expect(_braceL);
-	while (!eat(_braceR)) {
-	  var stmt = parseStatement();
-	  node.body.push(stmt);
-	  if (first && allowStrict && isUseStrict(stmt)) {
-		oldStrict = strict;
-		setStrict(strict = true);
-	  }
-	  first = false;
-	}
-	if (strict && !oldStrict) setStrict(false);
-	return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-	node.init = init;
-	expect(_semi);
-	node.test = tokType === _semi ? null : parseExpression();
-	expect(_semi);
-	node.update = tokType === _parenR ? null : parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-	node.left = init;
-	node.right = parseExpression();
-	expect(_parenR);
-	node.body = parseStatement();
-	labels.pop();
-	return finishNode(node, "ForInStatement");
-  }
-
-  function parseVar(node, noIn) {
-	node.declarations = [];
-	node.kind = "var";
-	for (;;) {
-	  var decl = startNode();
-	  decl.id = parseIdent();
-	  if (strict && isStrictBadIdWord(decl.id.name))
-		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
-	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
-	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
-	  if (!eat(_comma)) break;
-	}
-	return node;
-  }
-
-  function parseExpression(noComma, noIn) {
-	var expr = parseMaybeAssign(noIn);
-	if (!noComma && tokType === _comma) {
-	  var node = startNodeFrom(expr);
-	  node.expressions = [expr];
-	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
-	  return finishNode(node, "SequenceExpression");
-	}
-	return expr;
-  }
-
-  function parseMaybeAssign(noIn) {
-	var left = parseMaybeConditional(noIn);
-	if (tokType.isAssign) {
-	  var node = startNodeFrom(left);
-	  node.operator = tokVal;
-	  node.left = left;
-	  next();
-	  node.right = parseMaybeAssign(noIn);
-	  checkLVal(left);
-	  return finishNode(node, "AssignmentExpression");
-	}
-	return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-	var expr = parseExprOps(noIn);
-	if (eat(_question)) {
-	  var node = startNodeFrom(expr);
-	  node.test = expr;
-	  node.consequent = parseExpression(true);
-	  expect(_colon);
-	  node.alternate = parseExpression(true, noIn);
-	  return finishNode(node, "ConditionalExpression");
-	}
-	return expr;
-  }
-
-  function parseExprOps(noIn) {
-	return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
-
-  function parseExprOp(left, minPrec, noIn) {
-	var prec = tokType.binop;
-	if (prec != null && (!noIn || tokType !== _in)) {
-	  if (prec > minPrec) {
-		var node = startNodeFrom(left);
-		node.left = left;
-		node.operator = tokVal;
-		var op = tokType;
-		next();
-		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
-		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-		return parseExprOp(exprNode, minPrec, noIn);
-	  }
-	}
-	return left;
-  }
-
-  function parseMaybeUnary() {
-	if (tokType.prefix) {
-	  var node = startNode(), update = tokType.isUpdate;
-	  node.operator = tokVal;
-	  node.prefix = true;
-	  tokRegexpAllowed = true;
-	  next();
-	  node.argument = parseMaybeUnary();
-	  if (update) checkLVal(node.argument);
-	  else if (strict && node.operator === "delete" &&
-			   node.argument.type === "Identifier")
-		raise(node.start, "Deleting local variable in strict mode");
-	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
-	}
-	var expr = parseExprSubscripts();
-	while (tokType.postfix && !canInsertSemicolon()) {
-	  var node = startNodeFrom(expr);
-	  node.operator = tokVal;
-	  node.prefix = false;
-	  node.argument = expr;
-	  checkLVal(expr);
-	  next();
-	  expr = finishNode(node, "UpdateExpression");
-	}
-	return expr;
-  }
-
-  function parseExprSubscripts() {
-	return parseSubscripts(parseExprAtom());
-  }
-
-  function parseSubscripts(base, noCalls) {
-	if (eat(_dot)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseIdent(true);
-	  node.computed = false;
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (eat(_bracketL)) {
-	  var node = startNodeFrom(base);
-	  node.object = base;
-	  node.property = parseExpression();
-	  node.computed = true;
-	  expect(_bracketR);
-	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
-	} else if (!noCalls && eat(_parenL)) {
-	  var node = startNodeFrom(base);
-	  node.callee = base;
-	  node.arguments = parseExprList(_parenR, false);
-	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
-	} else return base;
-  }
-
-  function parseExprAtom() {
-	switch (tokType) {
-	case _this:
-	  var node = startNode();
-	  next();
-	  return finishNode(node, "ThisExpression");
-	case _name:
-	  return parseIdent();
-	case _num: case _string: case _regexp:
-	  var node = startNode();
-	  node.value = tokVal;
-	  node.raw = input.slice(tokStart, tokEnd);
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _null: case _true: case _false:
-	  var node = startNode();
-	  node.value = tokType.atomValue;
-	  node.raw = tokType.keyword;
-	  next();
-	  return finishNode(node, "Literal");
-
-	case _parenL:
-	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
-	  next();
-	  var val = parseExpression();
-	  val.start = tokStart1;
-	  val.end = tokEnd;
-	  if (options.locations) {
-		val.loc.start = tokStartLoc1;
-		val.loc.end = tokEndLoc;
-	  }
-	  if (options.ranges)
-		val.range = [tokStart1, tokEnd];
-	  expect(_parenR);
-	  return val;
-
-	case _bracketL:
-	  var node = startNode();
-	  next();
-	  node.elements = parseExprList(_bracketR, true, true);
-	  return finishNode(node, "ArrayExpression");
-
-	case _braceL:
-	  return parseObj();
-
-	case _function:
-	  var node = startNode();
-	  next();
-	  return parseFunction(node, false);
-
-	case _new:
-	  return parseNew();
-
-	default:
-	  unexpected();
-	}
-  }
-
-  function parseNew() {
-	var node = startNode();
-	next();
-	node.callee = parseSubscripts(parseExprAtom(), true);
-	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
-	else node.arguments = empty;
-	return finishNode(node, "NewExpression");
-  }
-
-  function parseObj() {
-	var node = startNode(), first = true, sawGetSet = false;
-	node.properties = [];
-	next();
-	while (!eat(_braceR)) {
-	  if (!first) {
-		expect(_comma);
-		if (options.allowTrailingCommas && eat(_braceR)) break;
-	  } else first = false;
-
-	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
-	  if (eat(_colon)) {
-		prop.value = parseExpression(true);
-		kind = prop.kind = "init";
-	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-				 (prop.key.name === "get" || prop.key.name === "set")) {
-		isGetSet = sawGetSet = true;
-		kind = prop.kind = prop.key.name;
-		prop.key = parsePropertyName();
-		if (tokType !== _parenL) unexpected();
-		prop.value = parseFunction(startNode(), false);
-	  } else unexpected();
-
-	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-		for (var i = 0; i < node.properties.length; ++i) {
-		  var other = node.properties[i];
-		  if (other.key.name === prop.key.name) {
-			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-			  kind === "init" && (other.kind === "get" || other.kind === "set");
-			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-			if (conflict) raise(prop.key.start, "Redefinition of property");
-		  }
-		}
-	  }
-	  node.properties.push(prop);
-	}
-	return finishNode(node, "ObjectExpression");
-  }
-
-  function parsePropertyName() {
-	if (tokType === _num || tokType === _string) return parseExprAtom();
-	return parseIdent(true);
-  }
-
-  function parseFunction(node, isStatement) {
-	if (tokType === _name) node.id = parseIdent();
-	else if (isStatement) unexpected();
-	else node.id = null;
-	node.params = [];
-	var first = true;
-	expect(_parenL);
-	while (!eat(_parenR)) {
-	  if (!first) expect(_comma); else first = false;
-	  node.params.push(parseIdent());
-	}
-
-	var oldInFunc = inFunction, oldLabels = labels;
-	inFunction = true; labels = [];
-	node.body = parseBlock(true);
-	inFunction = oldInFunc; labels = oldLabels;
-
-	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
-	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
-		var id = i < 0 ? node.id : node.params[i];
-		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-		  raise(id.start, "Defining '" + id.name + "' in strict mode");
-		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-		  raise(id.start, "Argument name clash in strict mode");
-	  }
-	}
-
-	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseExprList(close, allowTrailingComma, allowEmpty) {
-	var elts = [], first = true;
-	while (!eat(close)) {
-	  if (!first) {
-		expect(_comma);
-		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
-	  } else first = false;
-
-	  if (allowEmpty && tokType === _comma) elts.push(null);
-	  else elts.push(parseExpression(true));
-	}
-	return elts;
-  }
-
-  function parseIdent(liberal) {
-	var node = startNode();
-	if (liberal && options.forbidReserved == "everywhere") liberal = false;
-	if (tokType === _name) {
-	  if (!liberal &&
-		  (options.forbidReserved &&
-		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-		   strict && isStrictReservedWord(tokVal)) &&
-		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-	  node.name = tokVal;
-	} else if (liberal && tokType.keyword) {
-	  node.name = tokType.keyword;
-	} else {
-	  unexpected();
-	}
-	tokRegexpAllowed = false;
-	next();
-	return finishNode(node, "Identifier");
-  }
-
-});
-
-		if (!acorn.version)
-			acorn = null;
-	}
-
-	function parse(code, options) {
-		return (global.acorn || acorn).parse(code, options);
-	}
-
-	var binaryOperators = {
-		'+': '__add',
-		'-': '__subtract',
-		'*': '__multiply',
-		'/': '__divide',
-		'%': '__modulo',
-		'==': '__equals',
-		'!=': '__equals'
-	};
-
-	var unaryOperators = {
-		'-': '__negate',
-		'+': '__self'
-	};
-
-	var fields = Base.each(
-		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
-		function(name) {
-			this['__' + name] = '#' + name;
-		},
-		{
-			__self: function() {
-				return this;
-			}
-		}
-	);
-	Point.inject(fields);
-	Size.inject(fields);
-	Color.inject(fields);
-
-	function __$__(left, operator, right) {
-		var handler = binaryOperators[operator];
-		if (left && left[handler]) {
-			var res = left[handler](right);
-			return operator === '!=' ? !res : res;
-		}
-		switch (operator) {
-		case '+': return left + right;
-		case '-': return left - right;
-		case '*': return left * right;
-		case '/': return left / right;
-		case '%': return left % right;
-		case '==': return left == right;
-		case '!=': return left != right;
-		}
-	}
-
-	function $__(operator, value) {
-		var handler = unaryOperators[operator];
-		if (value && value[handler])
-			return value[handler]();
-		switch (operator) {
-		case '+': return +value;
-		case '-': return -value;
-		}
-	}
-
-	function compile(code, options) {
-		if (!code)
-			return '';
-		options = options || {};
-
-		var insertions = [];
-
-		function getOffset(offset) {
-			for (var i = 0, l = insertions.length; i < l; i++) {
-				var insertion = insertions[i];
-				if (insertion[0] >= offset)
-					break;
-				offset += insertion[1];
-			}
-			return offset;
-		}
-
-		function getCode(node) {
-			return code.substring(getOffset(node.range[0]),
-					getOffset(node.range[1]));
-		}
-
-		function getBetween(left, right) {
-			return code.substring(getOffset(left.range[1]),
-					getOffset(right.range[0]));
-		}
-
-		function replaceCode(node, str) {
-			var start = getOffset(node.range[0]),
-				end = getOffset(node.range[1]),
-				insert = 0;
-			for (var i = insertions.length - 1; i >= 0; i--) {
-				if (start > insertions[i][0]) {
-					insert = i + 1;
-					break;
-				}
-			}
-			insertions.splice(insert, 0, [start, str.length - end + start]);
-			code = code.substring(0, start) + str + code.substring(end);
-		}
-
-		function handleOverloading(node, parent) {
-			switch (node.type) {
-			case 'UnaryExpression':
-				if (node.operator in unaryOperators
-						&& node.argument.type !== 'Literal') {
-					var arg = getCode(node.argument);
-					replaceCode(node, '$__("' + node.operator + '", '
-							+ arg + ')');
-				}
-				break;
-			case 'BinaryExpression':
-				if (node.operator in binaryOperators
-						&& node.left.type !== 'Literal') {
-					var left = getCode(node.left),
-						right = getCode(node.right),
-						between = getBetween(node.left, node.right),
-						operator = node.operator;
-					replaceCode(node, '__$__(' + left + ','
-							+ between.replace(new RegExp('\\' + operator),
-								'"' + operator + '"')
-							+ ', ' + right + ')');
-				}
-				break;
-			case 'UpdateExpression':
-			case 'AssignmentExpression':
-				var parentType = parent && parent.type;
-				if (!(
-						parentType === 'ForStatement'
-						|| parentType === 'BinaryExpression'
-							&& /^[=!<>]/.test(parent.operator)
-						|| parentType === 'MemberExpression' && parent.computed
-				)) {
-					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument),
-							exp = '__$__(' + arg + ', "' + node.operator[0]
-									+ '", 1)',
-							str = arg + ' = ' + exp;
-						if (node.prefix) {
-							str = '(' + str + ')';
-						} else if (
-							parentType === 'AssignmentExpression' ||
-							parentType === 'VariableDeclarator' ||
-							parentType === 'BinaryExpression'
-						) {
-							if (getCode(parent.left || parent.id) === arg)
-								str = exp;
-							str = arg + '; ' + str;
-						}
-						replaceCode(node, str);
-					} else {
-						if (/^.=$/.test(node.operator)
-								&& node.left.type !== 'Literal') {
-							var left = getCode(node.left),
-								right = getCode(node.right),
-								exp = left + ' = __$__(' + left + ', "'
-									+ node.operator[0] + '", ' + right + ')';
-							replaceCode(node, /^\(.*\)$/.test(getCode(node))
-									? '(' + exp + ')' : exp);
-						}
-					}
-				}
-				break;
-			}
-		}
-
-		function handleExports(node) {
-			switch (node.type) {
-			case 'ExportDefaultDeclaration':
-				replaceCode({
-					range: [node.start, node.declaration.start]
-				}, 'module.exports = ');
-				break;
-			case 'ExportNamedDeclaration':
-				var declaration = node.declaration;
-				var specifiers = node.specifiers;
-				if (declaration) {
-					var declarations = declaration.declarations;
-					if (declarations) {
-						declarations.forEach(function(dec) {
-							replaceCode(dec, 'module.exports.' + getCode(dec));
-						});
-						replaceCode({
-							range: [
-								node.start,
-								declaration.start + declaration.kind.length
-							]
-						}, '');
-					}
-				} else if (specifiers) {
-					var exports = specifiers.map(function(specifier) {
-						var name = getCode(specifier);
-						return 'module.exports.' + name + ' = ' + name + '; ';
-					}).join('');
-					if (exports) {
-						replaceCode(node, exports);
-					}
-				}
-				break;
-			}
-		}
-
-		function walkAST(node, parent, paperFeatures) {
-			if (node) {
-				for (var key in node) {
-					if (key !== 'range' && key !== 'loc') {
-						var value = node[key];
-						if (Array.isArray(value)) {
-							for (var i = 0, l = value.length; i < l; i++) {
-								walkAST(value[i], node, paperFeatures);
-							}
-						} else if (value && typeof value === 'object') {
-							walkAST(value, node, paperFeatures);
-						}
-					}
-				}
-				if (paperFeatures.operatorOverloading !== false) {
-					handleOverloading(node, parent);
-				}
-				if (paperFeatures.moduleExports !== false) {
-					handleExports(node);
-				}
-			}
-		}
-
-		function encodeVLQ(value) {
-			var res = '',
-				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
-			while (value || !res) {
-				var next = value & (32 - 1);
-				value >>= 5;
-				if (value)
-					next |= 32;
-				res += base64[next];
-			}
-			return res;
-		}
-
-		var url = options.url || '',
-			sourceMaps = options.sourceMaps,
-			paperFeatures = options.paperFeatures || {},
-			source = options.source || code,
-			offset = options.offset || 0,
-			agent = paper.agent,
-			version = agent.versionNumber,
-			offsetCode = false,
-			lineBreaks = /\r\n|\n|\r/mg,
-			map;
-		if (sourceMaps && (agent.chrome && version >= 30
-				|| agent.webkit && version >= 537.76
-				|| agent.firefox && version >= 23
-				|| agent.node)) {
-			if (agent.node) {
-				offset -= 2;
-			} else if (window && url && !window.location.href.indexOf(url)) {
-				var html = document.getElementsByTagName('html')[0].innerHTML;
-				offset = html.substr(0, html.indexOf(code) + 1).match(
-						lineBreaks).length + 1;
-			}
-			offsetCode = offset > 0 && !(
-					agent.chrome && version >= 36 ||
-					agent.safari && version >= 600 ||
-					agent.firefox && version >= 40 ||
-					agent.node);
-			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
-			mappings.length = (code.match(lineBreaks) || []).length + 1
-					+ (offsetCode ? offset : 0);
-			map = {
-				version: 3,
-				file: url,
-				names:[],
-				mappings: mappings.join(';AACA'),
-				sourceRoot: '',
-				sources: [url],
-				sourcesContent: [source]
-			};
-		}
-		if (paperFeatures.operatorOverloading !== false) {
-			walkAST(parse(code, {
-				ranges: true,
-				preserveParens: true,
-				sourceType: 'module'
-			}), null, paperFeatures);
-		}
-		if (map) {
-			if (offsetCode) {
-				code = new Array(offset + 1).join('\n') + code;
-			}
-			if (/^(inline|both)$/.test(sourceMaps)) {
-				code += "\n//# sourceMappingURL=data:application/json;base64,"
-						+ self.btoa(unescape(encodeURIComponent(
-							JSON.stringify(map))));
-			}
-			code += "\n//# sourceURL=" + (url || 'paperscript');
-		}
-		return {
-			url: url,
-			source: source,
-			code: code,
-			map: map
-		};
-	}
-
-	function execute(code, scope, options) {
-		paper = scope;
-		var view = scope.getView(),
-			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
-					.test(code) && !/\bnew\s+Tool\b/.test(code)
-						? new Tool() : null,
-			toolHandlers = tool ? tool._events : [],
-			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
-			params = [],
-			args = [],
-			func,
-			compiled = typeof code === 'object' ? code : compile(code, options);
-		code = compiled.code;
-		function expose(scope, hidden) {
-			for (var key in scope) {
-				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
-						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
-					params.push(key);
-					args.push(scope[key]);
-				}
-			}
-		}
-		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
-				true);
-		expose(scope);
-		code = 'var module = { exports: {} }; ' + code;
-		var exports = Base.each(handlers, function(key) {
-			if (new RegExp('\\s+' + key + '\\b').test(code)) {
-				params.push(key);
-				this.push('module.exports.' + key + ' = ' + key + ';');
-			}
-		}, []).join('\n');
-		if (exports) {
-			code += '\n' + exports;
-		}
-		code += '\nreturn module.exports;';
-		var agent = paper.agent;
-		if (document && (agent.chrome
-				|| agent.firefox && agent.versionNumber < 40)) {
-			var script = document.createElement('script'),
-				head = document.head || document.getElementsByTagName('head')[0];
-			if (agent.firefox)
-				code = '\n' + code;
-			script.appendChild(document.createTextNode(
-				'document.__paperscript__ = function(' + params + ') {' +
-					code +
-				'\n}'
-			));
-			head.appendChild(script);
-			func = document.__paperscript__;
-			delete document.__paperscript__;
-			head.removeChild(script);
-		} else {
-			func = Function(params, code);
-		}
-		var exports = func && func.apply(scope, args);
-		var obj = exports || {};
-		Base.each(toolHandlers, function(key) {
-			var value = obj[key];
-			if (value)
-				tool[key] = value;
-		});
-		if (view) {
-			if (obj.onResize)
-				view.setOnResize(obj.onResize);
-			view.emit('resize', {
-				size: view.size,
-				delta: new Point()
-			});
-			if (obj.onFrame)
-				view.setOnFrame(obj.onFrame);
-			view.requestUpdate();
-		}
-		return exports;
-	}
-
-	function loadScript(script) {
-		if (/^text\/(?:x-|)paperscript$/.test(script.type)
-				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
-			var canvasId = PaperScope.getAttribute(script, 'canvas'),
-				canvas = document.getElementById(canvasId),
-				src = script.src || script.getAttribute('data-src'),
-				async = PaperScope.hasAttribute(script, 'async'),
-				scopeAttribute = 'data-paper-scope';
-			if (!canvas)
-				throw new Error('Unable to find canvas with id "'
-						+ canvasId + '"');
-			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
-						|| new PaperScope().setup(canvas);
-			canvas.setAttribute(scopeAttribute, scope._id);
-			if (src) {
-				Http.request({
-					url: src,
-					async: async,
-					mimeType: 'text/plain',
-					onLoad: function(code) {
-						execute(code, scope, src);
-					}
-				});
-			} else {
-				execute(script.innerHTML, scope, script.baseURI);
-			}
-			script.setAttribute('data-paper-ignore', 'true');
-			return scope;
-		}
-	}
-
-	function loadAll() {
-		Base.each(document && document.getElementsByTagName('script'),
-				loadScript);
-	}
-
-	function load(script) {
-		return script ? loadScript(script) : loadAll();
-	}
-
-	if (window) {
-		if (document.readyState === 'complete') {
-			setTimeout(loadAll);
-		} else {
-			DomEvent.add(window, { load: loadAll });
-		}
-	}
-
-	return {
-		compile: compile,
-		execute: execute,
-		load: load,
-		parse: parse,
-		calculateBinary: __$__,
-		calculateUnary: $__
-	};
-
-}.call(this);
-
-var paper = new (PaperScope.inject(Base.exports, {
-	Base: Base,
-	Numerical: Numerical,
-	Key: Key,
-	DomEvent: DomEvent,
-	DomElement: DomElement,
-	document: document,
-	window: window,
-	Symbol: SymbolDefinition,
-	PlacedSymbol: SymbolItem
-}))();
-
-if (paper.agent.node) {
-	require('./node/extend.js')(paper);
-}
-
-if (typeof define === 'function' && define.amd) {
-	define('paper', paper);
-} else if (typeof module === 'object' && module) {
-	module.exports = paper;
-}
-
-return paper;
-}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 120000
index 00000000..37e257c7
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1 @@
+../src/load.js
\ No newline at end of file

From b6d01e55e528aba9093c9651c7e362ed8baa2e18 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 21:42:04 +0200
Subject: [PATCH 176/181] Finally fix weird issues with publish tasks

See https://github.com/lehni/gulp-git-streamed/commit/b65527e3604f0c1d7a538c6a7cc13e7f8c0208b9
---
 gulp/tasks/publish.js |  1 -
 package.json          | 34 ++++++++++++++++++++++++++++++----
 2 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 53c77fa1..25d37a00 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -105,7 +105,6 @@ packages.forEach(function(name) {
             .pipe(git.commit(releaseMessage, opts))
             .pipe(git.tag('v' + options.version, releaseMessage, opts))
             .pipe(git.push('origin', 'master', { args: '--tags', cwd: path }))
-            .pipe(shell('echo <%= file.path %>'))
             .pipe(shell('npm publish', opts));
     });
 });
diff --git a/package.json b/package.json
index 56d57127..ed31939b 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,10 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"],
+  "contributors": [
+    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
+    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
+  ],
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
   "scripts": {
@@ -21,7 +24,14 @@
     "jshint": "gulp jshint",
     "test": "gulp test"
   },
-  "files": ["AUTHORS.md", "CHANGELOG.md", "dist/", "examples/", "LICENSE.txt", "README.md"],
+  "files": [
+    "AUTHORS.md",
+    "CHANGELOG.md",
+    "dist/",
+    "examples/",
+    "LICENSE.txt",
+    "README.md"
+  ],
   "engines": {
     "node": ">=8.0.0"
   },
@@ -45,7 +55,7 @@
     "del": "^4.1.0",
     "gulp": "^3.9.1",
     "gulp-cached": "^1.1.0",
-    "gulp-git-streamed": "^2.8.1",
+    "gulp-git-streamed": "^2.10.1",
     "gulp-jshint": "^2.1.0",
     "gulp-json-editor": "^2.5.2",
     "gulp-prepro": "^2.4.0",
@@ -76,5 +86,21 @@
     "straps": "^3.0.1",
     "typescript": "^3.1.6"
   },
-  "keywords": ["vector", "graphic", "graphics", "2d", "geometry", "bezier", "curve", "curves", "path", "paths", "canvas", "svg", "paper", "paper.js", "paperjs"]
+  "keywords": [
+    "vector",
+    "graphic",
+    "graphics",
+    "2d",
+    "geometry",
+    "bezier",
+    "curve",
+    "curves",
+    "path",
+    "paths",
+    "canvas",
+    "svg",
+    "paper",
+    "paper.js",
+    "paperjs"
+  ]
 }

From c20ead17c87865f988405e9fc2eda5d3789ffc5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 22:01:12 +0200
Subject: [PATCH 177/181] Make moduleExports work independently from
 operatorOverloading

---
 CHANGELOG.md            | 7 +++++++
 src/core/PaperScript.js | 5 ++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 80d810da..330036c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Change Log
 
+## Unreleased
+
+### Fixed
+
+- PaperScript: Make `options.paperFeatures.moduleExports` work independently
+  from `options.paperFeatures.operatorOverloading`.
+
 ## `0.12.6`
 
 ### Added
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index 791cd798..06accec0 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -420,7 +420,10 @@ Base.exports.PaperScript = function() {
                 sourcesContent: [source]
             };
         }
-        if (paperFeatures.operatorOverloading !== false) {
+        if (
+            paperFeatures.operatorOverloading !== false ||
+            paperFeatures.moduleExports !== false
+        ) {
             // Now do the parsing magic
             walkAST(parse(code, {
                 ranges: true,

From e4a0d2d665a031be21704346ff2f8af542f861d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 22:06:29 +0200
Subject: [PATCH 178/181] Avoid publishing paperjs.zip to NPM

---
 dist/.npmignore | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 dist/.npmignore

diff --git a/dist/.npmignore b/dist/.npmignore
new file mode 100644
index 00000000..819b6e42
--- /dev/null
+++ b/dist/.npmignore
@@ -0,0 +1 @@
+paperjs.zip

From db82f41151be5cd4a347ab368ac093c633551acf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 22:24:42 +0200
Subject: [PATCH 179/181] Update year, author email addresses and links

---
 AUTHORS.md                                              | 2 +-
 LICENSE.txt                                             | 4 ++--
 bower.json                                              | 4 ++--
 gulp/tasks/build.js                                     | 4 ++--
 gulp/tasks/dist.js                                      | 4 ++--
 gulp/tasks/docs.js                                      | 4 ++--
 gulp/tasks/jshint.js                                    | 4 ++--
 gulp/tasks/load.js                                      | 4 ++--
 gulp/tasks/minify.js                                    | 4 ++--
 gulp/tasks/publish.js                                   | 4 ++--
 gulp/tasks/test.js                                      | 4 ++--
 gulp/tasks/watch.js                                     | 4 ++--
 gulp/typescript/typescript-definition-template.mustache | 4 ++--
 gulp/utils/error.js                                     | 4 ++--
 gulp/utils/options.js                                   | 4 ++--
 gulpfile.js                                             | 4 ++--
 package.json                                            | 2 +-
 src/anim/Tween.js                                       | 4 ++--
 src/basic/Line.js                                       | 4 ++--
 src/basic/Matrix.js                                     | 4 ++--
 src/basic/Point.js                                      | 4 ++--
 src/basic/Rectangle.js                                  | 4 ++--
 src/basic/Size.js                                       | 4 ++--
 src/canvas/BlendMode.js                                 | 4 ++--
 src/canvas/CanvasProvider.js                            | 4 ++--
 src/canvas/ProxyContext.js                              | 4 ++--
 src/constants.js                                        | 4 ++--
 src/core/Base.js                                        | 4 ++--
 src/core/Emitter.js                                     | 4 ++--
 src/core/PaperScope.js                                  | 4 ++--
 src/core/PaperScopeItem.js                              | 4 ++--
 src/core/PaperScript.js                                 | 4 ++--
 src/docs/global.js                                      | 4 ++--
 src/dom/DomElement.js                                   | 4 ++--
 src/dom/DomEvent.js                                     | 4 ++--
 src/event/Event.js                                      | 4 ++--
 src/event/Key.js                                        | 4 ++--
 src/event/KeyEvent.js                                   | 4 ++--
 src/event/MouseEvent.js                                 | 4 ++--
 src/export.js                                           | 4 ++--
 src/init.js                                             | 4 ++--
 src/item/ChangeFlag.js                                  | 4 ++--
 src/item/Group.js                                       | 4 ++--
 src/item/HitResult.js                                   | 4 ++--
 src/item/Item.js                                        | 4 ++--
 src/item/ItemSelection.js                               | 4 ++--
 src/item/Layer.js                                       | 4 ++--
 src/item/Project.js                                     | 4 ++--
 src/item/Raster.js                                      | 4 ++--
 src/item/Shape.js                                       | 4 ++--
 src/item/SymbolDefinition.js                            | 4 ++--
 src/item/SymbolItem.js                                  | 4 ++--
 src/load.js                                             | 4 ++--
 src/net/Http.js                                         | 4 ++--
 src/node/canvas.js                                      | 4 ++--
 src/node/extend.js                                      | 4 ++--
 src/node/self.js                                        | 4 ++--
 src/node/xml.js                                         | 4 ++--
 src/options.js                                          | 4 ++--
 src/paper.js                                            | 8 ++++----
 src/path/CompoundPath.js                                | 4 ++--
 src/path/Curve.js                                       | 4 ++--
 src/path/CurveLocation.js                               | 4 ++--
 src/path/Path.Constructors.js                           | 4 ++--
 src/path/Path.js                                        | 4 ++--
 src/path/PathFitter.js                                  | 6 +++---
 src/path/PathFlattener.js                               | 4 ++--
 src/path/PathItem.Boolean.js                            | 6 +++---
 src/path/PathItem.js                                    | 6 +++---
 src/path/Segment.js                                     | 4 ++--
 src/path/SegmentPoint.js                                | 4 ++--
 src/path/SegmentSelection.js                            | 4 ++--
 src/style/Color.js                                      | 4 ++--
 src/style/Gradient.js                                   | 4 ++--
 src/style/GradientStop.js                               | 4 ++--
 src/style/Style.js                                      | 4 ++--
 src/svg/SvgElement.js                                   | 4 ++--
 src/svg/SvgExport.js                                    | 4 ++--
 src/svg/SvgImport.js                                    | 4 ++--
 src/svg/SvgStyles.js                                    | 4 ++--
 src/text/PointText.js                                   | 4 ++--
 src/text/TextItem.js                                    | 4 ++--
 src/tool/Tool.js                                        | 4 ++--
 src/tool/ToolEvent.js                                   | 4 ++--
 src/util/CollisionDetection.js                          | 4 ++--
 src/util/Formatter.js                                   | 4 ++--
 src/util/Numerical.js                                   | 4 ++--
 src/util/UID.js                                         | 4 ++--
 src/view/CanvasView.js                                  | 4 ++--
 src/view/View.js                                        | 4 ++--
 test/helpers.js                                         | 4 ++--
 test/load.js                                            | 4 ++--
 test/tests/Color.js                                     | 4 ++--
 test/tests/CompoundPath.js                              | 4 ++--
 test/tests/Curve.js                                     | 4 ++--
 test/tests/CurveLocation.js                             | 4 ++--
 test/tests/Emitter.js                                   | 4 ++--
 test/tests/Group.js                                     | 4 ++--
 test/tests/HitResult.js                                 | 4 ++--
 test/tests/Interactions.js                              | 4 ++--
 test/tests/Item.js                                      | 4 ++--
 test/tests/Item_Bounds.js                               | 4 ++--
 test/tests/Item_Cloning.js                              | 4 ++--
 test/tests/Item_Getting.js                              | 4 ++--
 test/tests/Item_Order.js                                | 4 ++--
 test/tests/JSON.js                                      | 4 ++--
 test/tests/Layer.js                                     | 4 ++--
 test/tests/Matrix.js                                    | 4 ++--
 test/tests/Numerical.js                                 | 4 ++--
 test/tests/PaperScript.js                               | 4 ++--
 test/tests/Path.js                                      | 4 ++--
 test/tests/PathItem.js                                  | 5 ++---
 test/tests/PathItem_Contains.js                         | 4 ++--
 test/tests/Path_Boolean.js                              | 6 +++---
 test/tests/Path_Constructors.js                         | 4 ++--
 test/tests/Path_Intersections.js                        | 4 ++--
 test/tests/Point.js                                     | 4 ++--
 test/tests/Project.js                                   | 4 ++--
 test/tests/Raster.js                                    | 4 ++--
 test/tests/Rectangle.js                                 | 4 ++--
 test/tests/Segment.js                                   | 4 ++--
 test/tests/Shape.js                                     | 4 ++--
 test/tests/Size.js                                      | 4 ++--
 test/tests/Style.js                                     | 4 ++--
 test/tests/SvgExport.js                                 | 4 ++--
 test/tests/SvgImport.js                                 | 4 ++--
 test/tests/SymbolItem.js                                | 4 ++--
 test/tests/TextItem.js                                  | 4 ++--
 test/tests/load.js                                      | 4 ++--
 travis/deploy-prebuilt.sh                               | 4 ++--
 travis/install-assets.sh                                | 4 ++--
 travis/setup-git.sh                                     | 4 ++--
 132 files changed, 268 insertions(+), 269 deletions(-)

diff --git a/AUTHORS.md b/AUTHORS.md
index 6e6acab8..d8cb5a3a 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -1,7 +1,7 @@
 ## Authors
 
 - Jürg Lehni <juerg@scratchdisk.com>
-- Jonathan Puckey <jonathan@studiomoniker.com>
+- Jonathan Puckey <jonathan@puckey.studio>
 
 ## Contributors
 
diff --git a/LICENSE.txt b/LICENSE.txt
index 6b6c439e..84e905d8 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,5 +1,5 @@
-Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
-http://scratchdisk.com/ & https://puckey.studio/
+Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+http://juerglehni.com/ & https://puckey.studio/
 All rights reserved.
 
 The MIT License (MIT)
diff --git a/bower.json b/bower.json
index c1ae758a..87612109 100644
--- a/bower.json
+++ b/bower.json
@@ -9,8 +9,8 @@
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
   "authors": [
-    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
-    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
+    "Jürg Lehni <juerg@scratchdisk.com> (http://juerglehni.com)",
+    "Jonathan Puckey <jonathan@puckey.studio> (http://puckey.studio)"
   ],
   "main": "dist/paper-full.js",
   "ignore": [
diff --git a/gulp/tasks/build.js b/gulp/tasks/build.js
index 48ee18ca..70b51c07 100644
--- a/gulp/tasks/build.js
+++ b/gulp/tasks/build.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/dist.js b/gulp/tasks/dist.js
index 1cf2d950..f8716a9f 100644
--- a/gulp/tasks/dist.js
+++ b/gulp/tasks/dist.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/docs.js b/gulp/tasks/docs.js
index 6e20068d..c8a3e639 100644
--- a/gulp/tasks/docs.js
+++ b/gulp/tasks/docs.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/jshint.js b/gulp/tasks/jshint.js
index 987c96f4..288be598 100644
--- a/gulp/tasks/jshint.js
+++ b/gulp/tasks/jshint.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/load.js b/gulp/tasks/load.js
index d985e74a..edfad83d 100644
--- a/gulp/tasks/load.js
+++ b/gulp/tasks/load.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/minify.js b/gulp/tasks/minify.js
index 28d1b1aa..0bf063ab 100644
--- a/gulp/tasks/minify.js
+++ b/gulp/tasks/minify.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/publish.js b/gulp/tasks/publish.js
index 25d37a00..d2c3c0c2 100644
--- a/gulp/tasks/publish.js
+++ b/gulp/tasks/publish.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/test.js b/gulp/tasks/test.js
index 328db819..fc40913c 100644
--- a/gulp/tasks/test.js
+++ b/gulp/tasks/test.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/tasks/watch.js b/gulp/tasks/watch.js
index 28a4dbdd..b5673225 100644
--- a/gulp/tasks/watch.js
+++ b/gulp/tasks/watch.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/typescript/typescript-definition-template.mustache b/gulp/typescript/typescript-definition-template.mustache
index f043f061..b7e85e11 100644
--- a/gulp/typescript/typescript-definition-template.mustache
+++ b/gulp/typescript/typescript-definition-template.mustache
@@ -2,8 +2,8 @@
  * Paper.js v{{version}} - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/utils/error.js b/gulp/utils/error.js
index b61b9a82..288a19ef 100644
--- a/gulp/utils/error.js
+++ b/gulp/utils/error.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulp/utils/options.js b/gulp/utils/options.js
index e8b7c84d..6e9cbf60 100644
--- a/gulp/utils/options.js
+++ b/gulp/utils/options.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/gulpfile.js b/gulpfile.js
index ecb7f8d1..38d6a963 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/package.json b/package.json
index ed31939b..7298f5ce 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
   "bugs": "https://github.com/paperjs/paper.js/issues",
   "contributors": [
     "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
-    "Jonathan Puckey <jonathan@studiomoniker.com> (http://studiomoniker.com)"
+    "Jonathan Puckey <jonathan@puckey.studio> (http://studiomoniker.com)"
   ],
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
diff --git a/src/anim/Tween.js b/src/anim/Tween.js
index 765efa01..d521d081 100644
--- a/src/anim/Tween.js
+++ b/src/anim/Tween.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Line.js b/src/basic/Line.js
index a77fa087..62e66fc2 100644
--- a/src/basic/Line.js
+++ b/src/basic/Line.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Matrix.js b/src/basic/Matrix.js
index 4bddb67b..57f61d3e 100644
--- a/src/basic/Matrix.js
+++ b/src/basic/Matrix.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Point.js b/src/basic/Point.js
index eaca9822..85974a3e 100644
--- a/src/basic/Point.js
+++ b/src/basic/Point.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Rectangle.js b/src/basic/Rectangle.js
index be80cee3..c65e1fb6 100644
--- a/src/basic/Rectangle.js
+++ b/src/basic/Rectangle.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/basic/Size.js b/src/basic/Size.js
index ba2e3f0b..e30aae7b 100644
--- a/src/basic/Size.js
+++ b/src/basic/Size.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/BlendMode.js b/src/canvas/BlendMode.js
index ac9ea7d3..32a1dc52 100644
--- a/src/canvas/BlendMode.js
+++ b/src/canvas/BlendMode.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/CanvasProvider.js b/src/canvas/CanvasProvider.js
index 3ac0aac0..183fba70 100644
--- a/src/canvas/CanvasProvider.js
+++ b/src/canvas/CanvasProvider.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/canvas/ProxyContext.js b/src/canvas/ProxyContext.js
index 5a403b48..636bdea4 100644
--- a/src/canvas/ProxyContext.js
+++ b/src/canvas/ProxyContext.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/constants.js b/src/constants.js
index 0c84dbcf..40eca14e 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/Base.js b/src/core/Base.js
index dcb668ef..dc9088b9 100644
--- a/src/core/Base.js
+++ b/src/core/Base.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/Emitter.js b/src/core/Emitter.js
index 0e9724d1..ac4b43a8 100644
--- a/src/core/Emitter.js
+++ b/src/core/Emitter.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScope.js b/src/core/PaperScope.js
index 1b6bf757..02f09200 100644
--- a/src/core/PaperScope.js
+++ b/src/core/PaperScope.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScopeItem.js b/src/core/PaperScopeItem.js
index 8aa31a8b..fb506c30 100644
--- a/src/core/PaperScopeItem.js
+++ b/src/core/PaperScopeItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/core/PaperScript.js b/src/core/PaperScript.js
index 06accec0..ff4a8511 100644
--- a/src/core/PaperScript.js
+++ b/src/core/PaperScript.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/docs/global.js b/src/docs/global.js
index 29de23d9..8bb1a7d4 100644
--- a/src/docs/global.js
+++ b/src/docs/global.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/dom/DomElement.js b/src/dom/DomElement.js
index 6b92c895..70284bb9 100644
--- a/src/dom/DomElement.js
+++ b/src/dom/DomElement.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/dom/DomEvent.js b/src/dom/DomEvent.js
index 56ac214f..37ed76fb 100644
--- a/src/dom/DomEvent.js
+++ b/src/dom/DomEvent.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/Event.js b/src/event/Event.js
index 297282e0..320c9d18 100644
--- a/src/event/Event.js
+++ b/src/event/Event.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/Key.js b/src/event/Key.js
index be425b42..c9e79a73 100644
--- a/src/event/Key.js
+++ b/src/event/Key.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/KeyEvent.js b/src/event/KeyEvent.js
index b19539db..5f10a595 100644
--- a/src/event/KeyEvent.js
+++ b/src/event/KeyEvent.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/event/MouseEvent.js b/src/event/MouseEvent.js
index 6700cba3..ffdf3e27 100644
--- a/src/event/MouseEvent.js
+++ b/src/event/MouseEvent.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/export.js b/src/export.js
index dc4d5d9e..cdbabc46 100644
--- a/src/export.js
+++ b/src/export.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/init.js b/src/init.js
index 55415286..82ebf0cd 100644
--- a/src/init.js
+++ b/src/init.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/ChangeFlag.js b/src/item/ChangeFlag.js
index 4592c2c1..b802d9b1 100644
--- a/src/item/ChangeFlag.js
+++ b/src/item/ChangeFlag.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Group.js b/src/item/Group.js
index c3bd085c..7f8e146b 100644
--- a/src/item/Group.js
+++ b/src/item/Group.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/HitResult.js b/src/item/HitResult.js
index bb51f333..bdb19048 100644
--- a/src/item/HitResult.js
+++ b/src/item/HitResult.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Item.js b/src/item/Item.js
index 4f2f8140..6f6405fb 100644
--- a/src/item/Item.js
+++ b/src/item/Item.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/ItemSelection.js b/src/item/ItemSelection.js
index 4b928e4c..71340079 100644
--- a/src/item/ItemSelection.js
+++ b/src/item/ItemSelection.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Layer.js b/src/item/Layer.js
index 5229b1cb..60d6660d 100644
--- a/src/item/Layer.js
+++ b/src/item/Layer.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Project.js b/src/item/Project.js
index 8d69d55e..232a900f 100644
--- a/src/item/Project.js
+++ b/src/item/Project.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Raster.js b/src/item/Raster.js
index 3b083b53..9e9d920d 100644
--- a/src/item/Raster.js
+++ b/src/item/Raster.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/Shape.js b/src/item/Shape.js
index 3fe45773..53cec0f7 100644
--- a/src/item/Shape.js
+++ b/src/item/Shape.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/SymbolDefinition.js b/src/item/SymbolDefinition.js
index 3e907fb2..c65d6bf8 100644
--- a/src/item/SymbolDefinition.js
+++ b/src/item/SymbolDefinition.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/item/SymbolItem.js b/src/item/SymbolItem.js
index 01b6a779..021cabbd 100644
--- a/src/item/SymbolItem.js
+++ b/src/item/SymbolItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/load.js b/src/load.js
index d1f4dd7b..d4c6a471 100644
--- a/src/load.js
+++ b/src/load.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/net/Http.js b/src/net/Http.js
index 0e9b867f..d043b762 100644
--- a/src/net/Http.js
+++ b/src/net/Http.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/canvas.js b/src/node/canvas.js
index 335f3873..ee325d7d 100644
--- a/src/node/canvas.js
+++ b/src/node/canvas.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/extend.js b/src/node/extend.js
index a950e4b3..e3c9af57 100644
--- a/src/node/extend.js
+++ b/src/node/extend.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/self.js b/src/node/self.js
index 2ec77404..4fad478d 100644
--- a/src/node/self.js
+++ b/src/node/self.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/node/xml.js b/src/node/xml.js
index 74087246..36331d00 100644
--- a/src/node/xml.js
+++ b/src/node/xml.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/options.js b/src/options.js
index 9d8a8816..814a2705 100644
--- a/src/options.js
+++ b/src/options.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/paper.js b/src/paper.js
index de0350eb..dafcb72d 100644
--- a/src/paper.js
+++ b/src/paper.js
@@ -2,8 +2,8 @@
  * Paper.js v*#=*__options.version - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -15,8 +15,8 @@
  *
  * Straps.js - Class inheritance library with support for bean-style accessors
  *
- * Copyright (c) 2006 - 2019 Juerg Lehni
- * http://scratchdisk.com/
+ * Copyright (c) 2006 - 2020 Jürg Lehni
+ * http://juerglehni.com/
  *
  * Distributed under the MIT license.
  *
diff --git a/src/path/CompoundPath.js b/src/path/CompoundPath.js
index 4643942b..2404ad66 100644
--- a/src/path/CompoundPath.js
+++ b/src/path/CompoundPath.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Curve.js b/src/path/Curve.js
index c2f6c073..e0b173c8 100644
--- a/src/path/Curve.js
+++ b/src/path/Curve.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/CurveLocation.js b/src/path/CurveLocation.js
index 19de2c04..ca17fe7b 100644
--- a/src/path/CurveLocation.js
+++ b/src/path/CurveLocation.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Path.Constructors.js b/src/path/Path.Constructors.js
index b6db94f6..858d3e06 100644
--- a/src/path/Path.Constructors.js
+++ b/src/path/Path.Constructors.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/Path.js b/src/path/Path.js
index c934462e..899be6fd 100644
--- a/src/path/Path.js
+++ b/src/path/Path.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathFitter.js b/src/path/PathFitter.js
index b5e6e14c..8444a811 100644
--- a/src/path/PathFitter.js
+++ b/src/path/PathFitter.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -13,7 +13,7 @@
 // An Algorithm for Automatically Fitting Digitized Curves
 // by Philip J. Schneider
 // from "Graphics Gems", Academic Press, 1990
-// Modifications and optimizations of original algorithm by Juerg Lehni.
+// Modifications and optimizations of original algorithm by Jürg Lehni.
 
 /**
  * @name PathFitter
diff --git a/src/path/PathFlattener.js b/src/path/PathFlattener.js
index 2f7899d1..ac28d8f7 100644
--- a/src/path/PathFlattener.js
+++ b/src/path/PathFlattener.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/PathItem.Boolean.js b/src/path/PathItem.Boolean.js
index 9eadbf7b..44867f67 100644
--- a/src/path/PathItem.Boolean.js
+++ b/src/path/PathItem.Boolean.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -24,7 +24,7 @@
  *
  * @author Harikrishnan Gopalakrishnan <hari.exeption@gmail.com>
  * @author Jan Boesenberg <jan.boesenberg@gmail.com>
- * @author Juerg Lehni <juerg@scratchdisk.com>
+ * @author Jürg Lehni <juerg@scratchdisk.com>
  */
 PathItem.inject(new function() {
     var min = Math.min,
diff --git a/src/path/PathItem.js b/src/path/PathItem.js
index d11cf738..255e1aaf 100644
--- a/src/path/PathItem.js
+++ b/src/path/PathItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -722,7 +722,7 @@ var PathItem = Item.extend(/** @lends PathItem# */{
                 matched = [],
                 count = 0;
             ok = true;
-            var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);      
+            var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
             for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
                 var path1 = paths1[i1];
                 ok = false;
diff --git a/src/path/Segment.js b/src/path/Segment.js
index 4fa11d0f..50164d56 100644
--- a/src/path/Segment.js
+++ b/src/path/Segment.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/SegmentPoint.js b/src/path/SegmentPoint.js
index a6bf3428..b73adfcb 100644
--- a/src/path/SegmentPoint.js
+++ b/src/path/SegmentPoint.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/path/SegmentSelection.js b/src/path/SegmentSelection.js
index abe4af55..ddf81077 100644
--- a/src/path/SegmentSelection.js
+++ b/src/path/SegmentSelection.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Color.js b/src/style/Color.js
index 66293277..d97b6fc4 100644
--- a/src/style/Color.js
+++ b/src/style/Color.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Gradient.js b/src/style/Gradient.js
index 512a835b..5a228125 100644
--- a/src/style/Gradient.js
+++ b/src/style/Gradient.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/GradientStop.js b/src/style/GradientStop.js
index b1d2d427..47ca4569 100644
--- a/src/style/GradientStop.js
+++ b/src/style/GradientStop.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/style/Style.js b/src/style/Style.js
index a9a8399d..72609b91 100644
--- a/src/style/Style.js
+++ b/src/style/Style.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgElement.js b/src/svg/SvgElement.js
index f345dc50..c166c229 100644
--- a/src/svg/SvgElement.js
+++ b/src/svg/SvgElement.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgExport.js b/src/svg/SvgExport.js
index 4b091158..585cc5f6 100644
--- a/src/svg/SvgExport.js
+++ b/src/svg/SvgExport.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgImport.js b/src/svg/SvgImport.js
index b9e8d9ef..408427de 100644
--- a/src/svg/SvgImport.js
+++ b/src/svg/SvgImport.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/svg/SvgStyles.js b/src/svg/SvgStyles.js
index 9d8bab08..d9cbab1b 100644
--- a/src/svg/SvgStyles.js
+++ b/src/svg/SvgStyles.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/text/PointText.js b/src/text/PointText.js
index fabc566c..8dd17c51 100644
--- a/src/text/PointText.js
+++ b/src/text/PointText.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/text/TextItem.js b/src/text/TextItem.js
index 11cc315d..bb36dd48 100644
--- a/src/text/TextItem.js
+++ b/src/text/TextItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/tool/Tool.js b/src/tool/Tool.js
index 05110788..1824d695 100644
--- a/src/tool/Tool.js
+++ b/src/tool/Tool.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/tool/ToolEvent.js b/src/tool/ToolEvent.js
index b9747459..5a777617 100644
--- a/src/tool/ToolEvent.js
+++ b/src/tool/ToolEvent.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/CollisionDetection.js b/src/util/CollisionDetection.js
index 442ab9d9..27c718f1 100644
--- a/src/util/CollisionDetection.js
+++ b/src/util/CollisionDetection.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/Formatter.js b/src/util/Formatter.js
index 58fded28..d402b8e4 100644
--- a/src/util/Formatter.js
+++ b/src/util/Formatter.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/Numerical.js b/src/util/Numerical.js
index 5510ef0d..6b6a456d 100644
--- a/src/util/Numerical.js
+++ b/src/util/Numerical.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/util/UID.js b/src/util/UID.js
index 0c315f26..1a6dd806 100644
--- a/src/util/UID.js
+++ b/src/util/UID.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/view/CanvasView.js b/src/view/CanvasView.js
index 85eecfb3..cabb1359 100644
--- a/src/view/CanvasView.js
+++ b/src/view/CanvasView.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/src/view/View.js b/src/view/View.js
index 28a92cfb..beabc959 100644
--- a/src/view/View.js
+++ b/src/view/View.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/helpers.js b/test/helpers.js
index fcb0b356..03698eba 100644
--- a/test/helpers.js
+++ b/test/helpers.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/load.js b/test/load.js
index 0769f330..b4619122 100644
--- a/test/load.js
+++ b/test/load.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Color.js b/test/tests/Color.js
index bf572e29..7dfabeaa 100644
--- a/test/tests/Color.js
+++ b/test/tests/Color.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/CompoundPath.js b/test/tests/CompoundPath.js
index 2bad91e4..3e01d775 100644
--- a/test/tests/CompoundPath.js
+++ b/test/tests/CompoundPath.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Curve.js b/test/tests/Curve.js
index 82ea945f..c570dbd5 100644
--- a/test/tests/Curve.js
+++ b/test/tests/Curve.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/CurveLocation.js b/test/tests/CurveLocation.js
index 816a7337..bcba60da 100644
--- a/test/tests/CurveLocation.js
+++ b/test/tests/CurveLocation.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Emitter.js b/test/tests/Emitter.js
index 2bbfdc98..255f6f79 100644
--- a/test/tests/Emitter.js
+++ b/test/tests/Emitter.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Group.js b/test/tests/Group.js
index 5b9bc1b3..f31e172c 100644
--- a/test/tests/Group.js
+++ b/test/tests/Group.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/HitResult.js b/test/tests/HitResult.js
index e9926815..91367464 100644
--- a/test/tests/HitResult.js
+++ b/test/tests/HitResult.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Interactions.js b/test/tests/Interactions.js
index 299d564b..f364a3ee 100644
--- a/test/tests/Interactions.js
+++ b/test/tests/Interactions.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item.js b/test/tests/Item.js
index 5cf22cef..af6c7f01 100644
--- a/test/tests/Item.js
+++ b/test/tests/Item.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Bounds.js b/test/tests/Item_Bounds.js
index 3e9417d9..b3c52f56 100644
--- a/test/tests/Item_Bounds.js
+++ b/test/tests/Item_Bounds.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Cloning.js b/test/tests/Item_Cloning.js
index 723a2a20..404d79eb 100644
--- a/test/tests/Item_Cloning.js
+++ b/test/tests/Item_Cloning.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Getting.js b/test/tests/Item_Getting.js
index d561572f..79dd2688 100644
--- a/test/tests/Item_Getting.js
+++ b/test/tests/Item_Getting.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Item_Order.js b/test/tests/Item_Order.js
index 2d0adb2b..77297a52 100644
--- a/test/tests/Item_Order.js
+++ b/test/tests/Item_Order.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/JSON.js b/test/tests/JSON.js
index 656d63d2..8ea9ab88 100644
--- a/test/tests/JSON.js
+++ b/test/tests/JSON.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Layer.js b/test/tests/Layer.js
index 947f0ab4..4f25826f 100644
--- a/test/tests/Layer.js
+++ b/test/tests/Layer.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Matrix.js b/test/tests/Matrix.js
index ec499e4a..f35483b9 100644
--- a/test/tests/Matrix.js
+++ b/test/tests/Matrix.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Numerical.js b/test/tests/Numerical.js
index 4bf3040f..d7e74f86 100644
--- a/test/tests/Numerical.js
+++ b/test/tests/Numerical.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/PaperScript.js b/test/tests/PaperScript.js
index 1f2510c9..191e9b93 100644
--- a/test/tests/PaperScript.js
+++ b/test/tests/PaperScript.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path.js b/test/tests/Path.js
index 3eb8a20b..d0522c90 100644
--- a/test/tests/Path.js
+++ b/test/tests/Path.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/PathItem.js b/test/tests/PathItem.js
index 94d5638f..cc91bd01 100644
--- a/test/tests/PathItem.js
+++ b/test/tests/PathItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -176,5 +176,4 @@ test('PathItem#compare()', function() {
     equals(function() {
         return compoundPath1.compare(compoundPath3);
     }, false, 'Comparing two compound paths with one child having a different shape should return false.');
-    
 });
diff --git a/test/tests/PathItem_Contains.js b/test/tests/PathItem_Contains.js
index 4a07f48e..45aa60b4 100644
--- a/test/tests/PathItem_Contains.js
+++ b/test/tests/PathItem_Contains.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path_Boolean.js b/test/tests/Path_Boolean.js
index 1da22b66..6f9af42f 100644
--- a/test/tests/Path_Boolean.js
+++ b/test/tests/Path_Boolean.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
@@ -1176,7 +1176,7 @@ test('Isolated edge-cases from @iconexperience\'s boolean-test suite', function(
         ['M570,290l5.8176,33.58557l-28.17314,-14.439c-14.32289,2.0978 -28.17688,4.12693 -28.17688,4.12693l19.08162,-8.78834l-16.12739,-8.26544l27.9654,2.81326z', 'M538.5492,304.48516l11.83801,-5.45218l9.61279,0.96702l15.8176,23.58557z'],
         ['', ''],
         ['M419.20345,384.34607c5.84471,3.31306 8.73763,3.6008 9.66385,3.54578c0.42499,-0.23215 3.1344,-1.90017 6.91252,-9.02761c31.69382,-59.79056 16.74714,-243.86183 15.04159,-262.65257c-3.42808,-8.00965 -2.79156,-12.73288 -0.15048,-1.551l29.19538,-6.89574l-2.9917,-29.85552c34.20913,-3.42795 37.91991,47.22024 32.18962,22.95919c0.38462,1.62842 24.31406,221.98511 -20.27182,306.0966c-7.77973,14.6765 -19.84373,29.87172 -38.60351,37.019c-20.69209,7.88347 -41.8301,3.18373 -60.57335,-7.44083z', 'M450.8214,116.21167c-0.08956,-0.98671 -0.14261,-1.51768 -0.15048,-1.551l29.19538,-6.89574l2.99069,29.84549c-18.44587,1.84838 -28.02391,-12.02551 -32.0356,-21.39876z'],
-        ['M224.2508,238.43767c2.45124,34.92471 9.86647,54.1339 17.20117,64.07402c4.07985,5.52909 8.23969,8.37799 12.35502,9.97162c7.6805,2.97421 19.93299,3.22543 38.3191,-2.95557c81.13187,-27.27474 190.74601,-146.01269 198.63572,-155.10754c0.92148,-1.70426 1.39237,-2.07227 0.44507,-0.53656l25.35355,15.63944l29.94723,-4.25223c1.89126,13.31958 -6.82114,24.30584 -4.2348,20.11304c-5.40958,8.76963 -129.41512,146.85628 -231.02757,181.01613c-24.82193,8.34458 -52.91092,12.17808 -79.10499,2.03465c-15.35707,-5.9469 -28.53272,-16.15682 -38.96756,-30.29832c-16.97074,-22.99908 -25.95119,-55.26903 -28.7747,-95.49783z', 'M490.76181,154.42019c0.26299,-0.30316 0.41295,-0.48449 0.44507,-0.53656l25.35355,15.63944l-29.45692,4.18261c-1.21879,-8.58358 1.97318,-16.16889 3.6583,-19.28549z']
+        ['M224.2508,238.43767c2.45124,34.92471 9.86647,54.1339 17.20117,64.07402c4.07985,5.52909 8.23969,8.37799 12.35502,9.97162c7.6805,2.97421 19.93299,3.22543 38.3191,-2.95557c81.13187,-27.27474 190.74601,-146.01269 198.63572,-155.10754c0.92148,-1.70426 1.39237,-2.07227 0.44507,-0.53656l25.35355,15.63944l29.94723,-4.25223c1.89126,13.31958 -6.82114,24.30584 -4.2348,20.11304c-5.40958,8.76963 -129.41512,146.85628 -231.02757,181.01613c-24.82193,8.34458 -52.91092,12.17808 -79.10499,2.03465c-15.35707,-5.9469 -28.53272,-16.15682 -38.96756,-30.29832c-16.97074,-22.99908 -25.95119,-55.26903 -28.7747,-95.49783z', 'M490.76181,154.42020c0.26299,-0.30316 0.41295,-0.48449 0.44507,-0.53656l25.35355,15.63944l-29.45692,4.18261c-1.21879,-8.58358 1.97318,-16.16889 3.6583,-19.28549z']
     ];
     for (var i = 0; i < paths.length; i++) {
         var entry = paths[i],
diff --git a/test/tests/Path_Constructors.js b/test/tests/Path_Constructors.js
index e4eaa33f..f6dd9c50 100644
--- a/test/tests/Path_Constructors.js
+++ b/test/tests/Path_Constructors.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Path_Intersections.js b/test/tests/Path_Intersections.js
index eaeb2acd..2d316479 100644
--- a/test/tests/Path_Intersections.js
+++ b/test/tests/Path_Intersections.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Point.js b/test/tests/Point.js
index 46a415d6..e14aa18b 100644
--- a/test/tests/Point.js
+++ b/test/tests/Point.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Project.js b/test/tests/Project.js
index 31da0956..2626f95e 100644
--- a/test/tests/Project.js
+++ b/test/tests/Project.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Raster.js b/test/tests/Raster.js
index 32f56fbf..44855cce 100644
--- a/test/tests/Raster.js
+++ b/test/tests/Raster.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Rectangle.js b/test/tests/Rectangle.js
index 70de44ca..dcfd2e67 100644
--- a/test/tests/Rectangle.js
+++ b/test/tests/Rectangle.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Segment.js b/test/tests/Segment.js
index 29bb0434..b283a230 100644
--- a/test/tests/Segment.js
+++ b/test/tests/Segment.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Shape.js b/test/tests/Shape.js
index a5f770d4..6b3f442b 100644
--- a/test/tests/Shape.js
+++ b/test/tests/Shape.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Size.js b/test/tests/Size.js
index 14f3ac61..68a87da0 100644
--- a/test/tests/Size.js
+++ b/test/tests/Size.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/Style.js b/test/tests/Style.js
index 8e22e56c..7a780302 100644
--- a/test/tests/Style.js
+++ b/test/tests/Style.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SvgExport.js b/test/tests/SvgExport.js
index a9b2ca62..fb588a00 100644
--- a/test/tests/SvgExport.js
+++ b/test/tests/SvgExport.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SvgImport.js b/test/tests/SvgImport.js
index c155d643..a8c1f145 100644
--- a/test/tests/SvgImport.js
+++ b/test/tests/SvgImport.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/SymbolItem.js b/test/tests/SymbolItem.js
index 7eb82ba1..5a8cd983 100644
--- a/test/tests/SymbolItem.js
+++ b/test/tests/SymbolItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/TextItem.js b/test/tests/TextItem.js
index d544dcc2..ebd24889 100644
--- a/test/tests/TextItem.js
+++ b/test/tests/TextItem.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/test/tests/load.js b/test/tests/load.js
index a2546737..b51fd592 100644
--- a/test/tests/load.js
+++ b/test/tests/load.js
@@ -2,8 +2,8 @@
  * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
diff --git a/travis/deploy-prebuilt.sh b/travis/deploy-prebuilt.sh
index 4e786d91..1286b1ed 100755
--- a/travis/deploy-prebuilt.sh
+++ b/travis/deploy-prebuilt.sh
@@ -3,8 +3,8 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & https://puckey.studio/
+# Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+# http://juerglehni.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #
diff --git a/travis/install-assets.sh b/travis/install-assets.sh
index 8c1b9b8e..565fd2ed 100755
--- a/travis/install-assets.sh
+++ b/travis/install-assets.sh
@@ -3,8 +3,8 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & https://puckey.studio/
+# Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+# http://juerglehni.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #
diff --git a/travis/setup-git.sh b/travis/setup-git.sh
index 52021b5f..8e4c72ab 100755
--- a/travis/setup-git.sh
+++ b/travis/setup-git.sh
@@ -3,8 +3,8 @@
 # Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
 # http://paperjs.org/
 #
-# Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
-# http://scratchdisk.com/ & https://puckey.studio/
+# Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+# http://juerglehni.com/ & https://puckey.studio/
 #
 # Distributed under the MIT license. See LICENSE file for details.
 #

From 8a3b4c73de66df5b22174eb254a52f1a041da350 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 23:05:09 +0200
Subject: [PATCH 180/181] Update CHANGELOG

---
 CHANGELOG.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 330036c1..e4367a08 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,20 +4,22 @@
 
 ### Fixed
 
-- PaperScript: Make `options.paperFeatures.moduleExports` work independently
-  from `options.paperFeatures.operatorOverloading`.
+- PaperScript: Actually make `options.paperFeatures.moduleExports` work
+  independently from `options.paperFeatures.operatorOverloading`.
 
 ## `0.12.6`
 
 ### Added
 
-- PaperScript: Add option to control module exports conversion.
+- PaperScript: Add option `options.paperFeatures.moduleExports` to control
+  module exports conversion.
 
 ## `0.12.5`
 
 ### Added
 
-- PaperScript: Add option to control operator overloading.
+- PaperScript: Add option `options.paperFeatures.operatorOverloading` to control
+  operator overloading.
 
 ### Fixed
 

From 7bb34e46020f8ac1e20929bf6734fb728e48b72d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ju=CC=88rg=20Lehni?= <juerg@scratchdisk.com>
Date: Sat, 23 May 2020 23:10:15 +0200
Subject: [PATCH 181/181] Release version 0.12.7

---
 CHANGELOG.md                |     2 +-
 dist/paper-core.js          | 15653 +++++++++++++++++++++++++++++-
 dist/paper-full.js          | 17422 +++++++++++++++++++++++++++++++++-
 dist/paper.d.ts             |     8 +-
 package.json                |    34 +-
 packages/paper-jsdom        |     2 +-
 packages/paper-jsdom-canvas |     2 +-
 src/options.js              |     2 +-
 8 files changed, 33085 insertions(+), 40 deletions(-)
 mode change 120000 => 100644 dist/paper-core.js
 mode change 120000 => 100644 dist/paper-full.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e4367a08..68cf659d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## Unreleased
+## `0.12.7`
 
 ### Fixed
 
diff --git a/dist/paper-core.js b/dist/paper-core.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-core.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-core.js b/dist/paper-core.js
new file mode 100644
index 00000000..95fb5e9d
--- /dev/null
+++ b/dist/paper-core.js
@@ -0,0 +1,15652 @@
+/*!
+ * Paper.js v0.12.7 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 23:05:09 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2020 Jürg Lehni
+ * http://juerglehni.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.7",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper-full.js b/dist/paper-full.js
deleted file mode 120000
index 37e257c7..00000000
--- a/dist/paper-full.js
+++ /dev/null
@@ -1 +0,0 @@
-../src/load.js
\ No newline at end of file
diff --git a/dist/paper-full.js b/dist/paper-full.js
new file mode 100644
index 00000000..77b8683c
--- /dev/null
+++ b/dist/paper-full.js
@@ -0,0 +1,17421 @@
+/*!
+ * Paper.js v0.12.7 - The Swiss Army Knife of Vector Graphics Scripting.
+ * http://paperjs.org/
+ *
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
+ *
+ * Distributed under the MIT license. See LICENSE file for details.
+ *
+ * All rights reserved.
+ *
+ * Date: Sat May 23 23:05:09 2020 +0200
+ *
+ ***
+ *
+ * Straps.js - Class inheritance library with support for bean-style accessors
+ *
+ * Copyright (c) 2006 - 2020 Jürg Lehni
+ * http://juerglehni.com/
+ *
+ * Distributed under the MIT license.
+ *
+ ***
+ *
+ * Acorn.js
+ * https://marijnhaverbeke.nl/acorn/
+ *
+ * Acorn is a tiny, fast JavaScript parser written in JavaScript,
+ * created by Marijn Haverbeke and released under an MIT license.
+ *
+ */
+
+var paper = function(self, undefined) {
+
+self = self || require('./node/self.js');
+var window = self.window,
+	document = self.document;
+
+var Base = new function() {
+	var hidden = /^(statics|enumerable|beans|preserve)$/,
+		array = [],
+		slice = array.slice,
+		create = Object.create,
+		describe = Object.getOwnPropertyDescriptor,
+		define = Object.defineProperty,
+
+		forEach = array.forEach || function(iter, bind) {
+			for (var i = 0, l = this.length; i < l; i++) {
+				iter.call(bind, this[i], i, this);
+			}
+		},
+
+		forIn = function(iter, bind) {
+			for (var i in this) {
+				if (this.hasOwnProperty(i))
+					iter.call(bind, this[i], i, this);
+			}
+		},
+
+		set = Object.assign || function(dst) {
+			for (var i = 1, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				for (var key in src) {
+					if (src.hasOwnProperty(key))
+						dst[key] = src[key];
+				}
+			}
+			return dst;
+		},
+
+		each = function(obj, iter, bind) {
+			if (obj) {
+				var desc = describe(obj, 'length');
+				(desc && typeof desc.value === 'number' ? forEach : forIn)
+					.call(obj, iter, bind = bind || obj);
+			}
+			return bind;
+		};
+
+	function inject(dest, src, enumerable, beans, preserve) {
+		var beansNames = {};
+
+		function field(name, val) {
+			val = val || (val = describe(src, name))
+					&& (val.get ? val : val.value);
+			if (typeof val === 'string' && val[0] === '#')
+				val = dest[val.substring(1)] || val;
+			var isFunc = typeof val === 'function',
+				res = val,
+				prev = preserve || isFunc && !val.base
+						? (val && val.get ? name in dest : dest[name])
+						: null,
+				bean;
+			if (!preserve || !prev) {
+				if (isFunc && prev)
+					val.base = prev;
+				if (isFunc && beans !== false
+						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))
+					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];
+				if (!res || isFunc || !res.get || typeof res.get !== 'function'
+						|| !Base.isPlainObject(res)) {
+					res = { value: res, writable: true };
+				}
+				if ((describe(dest, name)
+						|| { configurable: true }).configurable) {
+					res.configurable = true;
+					res.enumerable = enumerable != null ? enumerable : !bean;
+				}
+				define(dest, name, res);
+			}
+		}
+		if (src) {
+			for (var name in src) {
+				if (src.hasOwnProperty(name) && !hidden.test(name))
+					field(name);
+			}
+			for (var name in beansNames) {
+				var part = beansNames[name],
+					set = dest['set' + part],
+					get = dest['get' + part] || set && dest['is' + part];
+				if (get && (beans === true || get.length === 0))
+					field(name, { get: get, set: set });
+			}
+		}
+		return dest;
+	}
+
+	function Base() {
+		for (var i = 0, l = arguments.length; i < l; i++) {
+			var src = arguments[i];
+			if (src)
+				set(this, src);
+		}
+		return this;
+	}
+
+	return inject(Base, {
+		inject: function(src) {
+			if (src) {
+				var statics = src.statics === true ? src : src.statics,
+					beans = src.beans,
+					preserve = src.preserve;
+				if (statics !== src)
+					inject(this.prototype, src, src.enumerable, beans, preserve);
+				inject(this, statics, null, beans, preserve);
+			}
+			for (var i = 1, l = arguments.length; i < l; i++)
+				this.inject(arguments[i]);
+			return this;
+		},
+
+		extend: function() {
+			var base = this,
+				ctor,
+				proto;
+			for (var i = 0, obj, l = arguments.length;
+					i < l && !(ctor && proto); i++) {
+				obj = arguments[i];
+				ctor = ctor || obj.initialize;
+				proto = proto || obj.prototype;
+			}
+			ctor = ctor || function() {
+				base.apply(this, arguments);
+			};
+			proto = ctor.prototype = proto || create(this.prototype);
+			define(proto, 'constructor',
+					{ value: ctor, writable: true, configurable: true });
+			inject(ctor, this);
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
+		}
+	}).inject({
+		enumerable: false,
+
+		initialize: Base,
+
+		set: Base,
+
+		inject: function() {
+			for (var i = 0, l = arguments.length; i < l; i++) {
+				var src = arguments[i];
+				if (src) {
+					inject(this, src, src.enumerable, src.beans, src.preserve);
+				}
+			}
+			return this;
+		},
+
+		extend: function() {
+			var res = create(this);
+			return res.inject.apply(res, arguments);
+		},
+
+		each: function(iter, bind) {
+			return each(this, iter, bind);
+		},
+
+		clone: function() {
+			return new this.constructor(this);
+		},
+
+		statics: {
+			set: set,
+			each: each,
+			create: create,
+			define: define,
+			describe: describe,
+
+			clone: function(obj) {
+				return set(new obj.constructor(), obj);
+			},
+
+			isPlainObject: function(obj) {
+				var ctor = obj != null && obj.constructor;
+				return ctor && (ctor === Object || ctor === Base
+						|| ctor.name === 'Object');
+			},
+
+			pick: function(a, b) {
+				return a !== undefined ? a : b;
+			},
+
+			slice: function(list, begin, end) {
+				return slice.call(list, begin, end);
+			}
+		}
+	});
+};
+
+if (typeof module !== 'undefined')
+	module.exports = Base;
+
+Base.inject({
+	enumerable: false,
+
+	toString: function() {
+		return this._id != null
+			?  (this._class || 'Object') + (this._name
+				? " '" + this._name + "'"
+				: ' @' + this._id)
+			: '{ ' + Base.each(this, function(value, key) {
+				if (!/^_/.test(key)) {
+					var type = typeof value;
+					this.push(key + ': ' + (type === 'number'
+							? Formatter.instance.number(value)
+							: type === 'string' ? "'" + value + "'" : value));
+				}
+			}, []).join(', ') + ' }';
+	},
+
+	getClassName: function() {
+		return this._class || '';
+	},
+
+	importJSON: function(json) {
+		return Base.importJSON(json, this);
+	},
+
+	exportJSON: function(options) {
+		return Base.exportJSON(this, options);
+	},
+
+	toJSON: function() {
+		return Base.serialize(this);
+	},
+
+	set: function(props, exclude) {
+		if (props)
+			Base.filter(this, props, exclude, this._prioritize);
+		return this;
+	}
+}, {
+
+beans: false,
+statics: {
+	exports: {},
+
+	extend: function extend() {
+		var res = extend.base.apply(this, arguments),
+			name = res.prototype._class;
+		if (name && !Base.exports[name])
+			Base.exports[name] = res;
+		return res;
+	},
+
+	equals: function(obj1, obj2) {
+		if (obj1 === obj2)
+			return true;
+		if (obj1 && obj1.equals)
+			return obj1.equals(obj2);
+		if (obj2 && obj2.equals)
+			return obj2.equals(obj1);
+		if (obj1 && obj2
+				&& typeof obj1 === 'object' && typeof obj2 === 'object') {
+			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+				var length = obj1.length;
+				if (length !== obj2.length)
+					return false;
+				while (length--) {
+					if (!Base.equals(obj1[length], obj2[length]))
+						return false;
+				}
+			} else {
+				var keys = Object.keys(obj1),
+					length = keys.length;
+				if (length !== Object.keys(obj2).length)
+					return false;
+				while (length--) {
+					var key = keys[length];
+					if (!(obj2.hasOwnProperty(key)
+							&& Base.equals(obj1[key], obj2[key])))
+						return false;
+				}
+			}
+			return true;
+		}
+		return false;
+	},
+
+	read: function(list, start, options, amount) {
+		if (this === Base) {
+			var value = this.peek(list, start);
+			list.__index++;
+			return value;
+		}
+		var proto = this.prototype,
+			readIndex = proto._readIndex,
+			begin = start || readIndex && list.__index || 0,
+			length = list.length,
+			obj = list[begin];
+		amount = amount || length - begin;
+		if (obj instanceof this
+			|| options && options.readNull && obj == null && amount <= 1) {
+			if (readIndex)
+				list.__index = begin + 1;
+			return obj && options && options.clone ? obj.clone() : obj;
+		}
+		obj = Base.create(proto);
+		if (readIndex)
+			obj.__read = true;
+		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length
+				? Base.slice(list, begin, begin + amount)
+				: list) || obj;
+		if (readIndex) {
+			list.__index = begin + obj.__read;
+			var filtered = obj.__filtered;
+			if (filtered) {
+				list.__filtered = filtered;
+				obj.__filtered = undefined;
+			}
+			obj.__read = undefined;
+		}
+		return obj;
+	},
+
+	peek: function(list, start) {
+		return list[list.__index = start || list.__index || 0];
+	},
+
+	remain: function(list) {
+		return list.length - (list.__index || 0);
+	},
+
+	readList: function(list, start, options, amount) {
+		var res = [],
+			entry,
+			begin = start || 0,
+			end = amount ? begin + amount : list.length;
+		for (var i = begin; i < end; i++) {
+			res.push(Array.isArray(entry = list[i])
+					? this.read(entry, 0, options)
+					: this.read(list, i, options, 1));
+		}
+		return res;
+	},
+
+	readNamed: function(list, name, start, options, amount) {
+		var value = this.getNamed(list, name),
+			hasValue = value !== undefined;
+		if (hasValue) {
+			var filtered = list.__filtered;
+			if (!filtered) {
+				var source = this.getSource(list);
+				filtered = list.__filtered = Base.create(source);
+				filtered.__unfiltered = source;
+			}
+			filtered[name] = undefined;
+		}
+		return this.read(hasValue ? [value] : list, start, options, amount);
+	},
+
+	readSupported: function(list, dest) {
+		var source = this.getSource(list),
+			that = this,
+			read = false;
+		if (source) {
+			Object.keys(source).forEach(function(key) {
+				if (key in dest) {
+					var value = that.readNamed(list, key);
+					if (value !== undefined) {
+						dest[key] = value;
+					}
+					read = true;
+				}
+			});
+		}
+		return read;
+	},
+
+	getSource: function(list) {
+		var source = list.__source;
+		if (source === undefined) {
+			var arg = list.length === 1 && list[0];
+			source = list.__source = arg && Base.isPlainObject(arg)
+				? arg : null;
+		}
+		return source;
+	},
+
+	getNamed: function(list, name) {
+		var source = this.getSource(list);
+		if (source) {
+			return name ? source[name] : list.__filtered || source;
+		}
+	},
+
+	hasNamed: function(list, name) {
+		return !!this.getNamed(list, name);
+	},
+
+	filter: function(dest, source, exclude, prioritize) {
+		var processed;
+
+		function handleKey(key) {
+			if (!(exclude && key in exclude) &&
+				!(processed && key in processed)) {
+				var value = source[key];
+				if (value !== undefined)
+					dest[key] = value;
+			}
+		}
+
+		if (prioritize) {
+			var keys = {};
+			for (var i = 0, key, l = prioritize.length; i < l; i++) {
+				if ((key = prioritize[i]) in source) {
+					handleKey(key);
+					keys[key] = true;
+				}
+			}
+			processed = keys;
+		}
+
+		Object.keys(source.__unfiltered || source).forEach(handleKey);
+		return dest;
+	},
+
+	isPlainValue: function(obj, asString) {
+		return Base.isPlainObject(obj) || Array.isArray(obj)
+				|| asString && typeof obj === 'string';
+	},
+
+	serialize: function(obj, options, compact, dictionary) {
+		options = options || {};
+
+		var isRoot = !dictionary,
+			res;
+		if (isRoot) {
+			options.formatter = new Formatter(options.precision);
+			dictionary = {
+				length: 0,
+				definitions: {},
+				references: {},
+				add: function(item, create) {
+					var id = '#' + item._id,
+						ref = this.references[id];
+					if (!ref) {
+						this.length++;
+						var res = create.call(item),
+							name = item._class;
+						if (name && res[0] !== name)
+							res.unshift(name);
+						this.definitions[id] = res;
+						ref = this.references[id] = [id];
+					}
+					return ref;
+				}
+			};
+		}
+		if (obj && obj._serialize) {
+			res = obj._serialize(options, dictionary);
+			var name = obj._class;
+			if (name && !obj._compactSerialize && (isRoot || !compact)
+					&& res[0] !== name) {
+				res.unshift(name);
+			}
+		} else if (Array.isArray(obj)) {
+			res = [];
+			for (var i = 0, l = obj.length; i < l; i++)
+				res[i] = Base.serialize(obj[i], options, compact, dictionary);
+		} else if (Base.isPlainObject(obj)) {
+			res = {};
+			var keys = Object.keys(obj);
+			for (var i = 0, l = keys.length; i < l; i++) {
+				var key = keys[i];
+				res[key] = Base.serialize(obj[key], options, compact,
+						dictionary);
+			}
+		} else if (typeof obj === 'number') {
+			res = options.formatter.number(obj, options.precision);
+		} else {
+			res = obj;
+		}
+		return isRoot && dictionary.length > 0
+				? [['dictionary', dictionary.definitions], res]
+				: res;
+	},
+
+	deserialize: function(json, create, _data, _setDictionary, _isRoot) {
+		var res = json,
+			isFirst = !_data,
+			hasDictionary = isFirst && json && json.length
+				&& json[0][0] === 'dictionary';
+		_data = _data || {};
+		if (Array.isArray(json)) {
+			var type = json[0],
+				isDictionary = type === 'dictionary';
+			if (json.length == 1 && /^#/.test(type)) {
+				return _data.dictionary[type];
+			}
+			type = Base.exports[type];
+			res = [];
+			for (var i = type ? 1 : 0, l = json.length; i < l; i++) {
+				res.push(Base.deserialize(json[i], create, _data,
+						isDictionary, hasDictionary));
+			}
+			if (type) {
+				var args = res;
+				if (create) {
+					res = create(type, args, isFirst || _isRoot);
+				} else {
+					res = new type(args);
+				}
+			}
+		} else if (Base.isPlainObject(json)) {
+			res = {};
+			if (_setDictionary)
+				_data.dictionary = res;
+			for (var key in json)
+				res[key] = Base.deserialize(json[key], create, _data);
+		}
+		return hasDictionary ? res[1] : res;
+	},
+
+	exportJSON: function(obj, options) {
+		var json = Base.serialize(obj, options);
+		return options && options.asString == false
+				? json
+				: JSON.stringify(json);
+	},
+
+	importJSON: function(json, target) {
+		return Base.deserialize(
+				typeof json === 'string' ? JSON.parse(json) : json,
+				function(ctor, args, isRoot) {
+					var useTarget = isRoot && target
+							&& target.constructor === ctor,
+						obj = useTarget ? target
+							: Base.create(ctor.prototype);
+					if (args.length === 1 && obj instanceof Item
+							&& (useTarget || !(obj instanceof Layer))) {
+						var arg = args[0];
+						if (Base.isPlainObject(arg)) {
+							arg.insert = false;
+							if (useTarget) {
+								args = args.concat([{ insert: true }]);
+							}
+						}
+					}
+					(useTarget ? obj.set : ctor).apply(obj, args);
+					if (useTarget)
+						target = null;
+					return obj;
+				});
+	},
+
+	push: function(list, items) {
+		var itemsLength = items.length;
+		if (itemsLength < 4096) {
+			list.push.apply(list, items);
+		} else {
+			var startLength = list.length;
+			list.length += itemsLength;
+			for (var i = 0; i < itemsLength; i++) {
+				list[startLength + i] = items[i];
+			}
+		}
+		return list;
+	},
+
+	splice: function(list, items, index, remove) {
+		var amount = items && items.length,
+			append = index === undefined;
+		index = append ? list.length : index;
+		if (index > list.length)
+			index = list.length;
+		for (var i = 0; i < amount; i++)
+			items[i]._index = index + i;
+		if (append) {
+			Base.push(list, items);
+			return [];
+		} else {
+			var args = [index, remove];
+			if (items)
+				Base.push(args, items);
+			var removed = list.splice.apply(list, args);
+			for (var i = 0, l = removed.length; i < l; i++)
+				removed[i]._index = undefined;
+			for (var i = index + amount, l = list.length; i < l; i++)
+				list[i]._index = i;
+			return removed;
+		}
+	},
+
+	capitalize: function(str) {
+		return str.replace(/\b[a-z]/g, function(match) {
+			return match.toUpperCase();
+		});
+	},
+
+	camelize: function(str) {
+		return str.replace(/-(.)/g, function(match, chr) {
+			return chr.toUpperCase();
+		});
+	},
+
+	hyphenate: function(str) {
+		return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+	}
+}});
+
+var Emitter = {
+	on: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.on(key, value);
+			}, this);
+		} else {
+			var types = this._eventTypes,
+				entry = types && types[type],
+				handlers = this._callbacks = this._callbacks || {};
+			handlers = handlers[type] = handlers[type] || [];
+			if (handlers.indexOf(func) === -1) {
+				handlers.push(func);
+				if (entry && entry.install && handlers.length === 1)
+					entry.install.call(this, type);
+			}
+		}
+		return this;
+	},
+
+	off: function(type, func) {
+		if (typeof type !== 'string') {
+			Base.each(type, function(value, key) {
+				this.off(key, value);
+			}, this);
+			return;
+		}
+		var types = this._eventTypes,
+			entry = types && types[type],
+			handlers = this._callbacks && this._callbacks[type],
+			index;
+		if (handlers) {
+			if (!func || (index = handlers.indexOf(func)) !== -1
+					&& handlers.length === 1) {
+				if (entry && entry.uninstall)
+					entry.uninstall.call(this, type);
+				delete this._callbacks[type];
+			} else if (index !== -1) {
+				handlers.splice(index, 1);
+			}
+		}
+		return this;
+	},
+
+	once: function(type, func) {
+		return this.on(type, function handler() {
+			func.apply(this, arguments);
+			this.off(type, handler);
+		});
+	},
+
+	emit: function(type, event) {
+		var handlers = this._callbacks && this._callbacks[type];
+		if (!handlers)
+			return false;
+		var args = Base.slice(arguments, 1),
+			setTarget = event && event.target && !event.currentTarget;
+		handlers = handlers.slice();
+		if (setTarget)
+			event.currentTarget = this;
+		for (var i = 0, l = handlers.length; i < l; i++) {
+			if (handlers[i].apply(this, args) == false) {
+				if (event && event.stop)
+					event.stop();
+				break;
+		   }
+		}
+		if (setTarget)
+			delete event.currentTarget;
+		return true;
+	},
+
+	responds: function(type) {
+		return !!(this._callbacks && this._callbacks[type]);
+	},
+
+	attach: '#on',
+	detach: '#off',
+	fire: '#emit',
+
+	_installEvents: function(install) {
+		var types = this._eventTypes,
+			handlers = this._callbacks,
+			key = install ? 'install' : 'uninstall';
+		if (types) {
+			for (var type in handlers) {
+				if (handlers[type].length > 0) {
+					var entry = types[type],
+						func = entry && entry[key];
+					if (func)
+						func.call(this, type);
+				}
+			}
+		}
+	},
+
+	statics: {
+		inject: function inject(src) {
+			var events = src._events;
+			if (events) {
+				var types = {};
+				Base.each(events, function(entry, key) {
+					var isString = typeof entry === 'string',
+						name = isString ? entry : key,
+						part = Base.capitalize(name),
+						type = name.substring(2).toLowerCase();
+					types[type] = isString ? {} : entry;
+					name = '_' + name;
+					src['get' + part] = function() {
+						return this[name];
+					};
+					src['set' + part] = function(func) {
+						var prev = this[name];
+						if (prev)
+							this.off(type, prev);
+						if (func)
+							this.on(type, func);
+						this[name] = func;
+					};
+				});
+				src._eventTypes = types;
+			}
+			return inject.base.apply(this, arguments);
+		}
+	}
+};
+
+var PaperScope = Base.extend({
+	_class: 'PaperScope',
+
+	initialize: function PaperScope() {
+		paper = this;
+		this.settings = new Base({
+			applyMatrix: true,
+			insertItems: true,
+			handleSize: 4,
+			hitTolerance: 0
+		});
+		this.project = null;
+		this.projects = [];
+		this.tools = [];
+		this._id = PaperScope._id++;
+		PaperScope._scopes[this._id] = this;
+		var proto = PaperScope.prototype;
+		if (!this.support) {
+			var ctx = CanvasProvider.getContext(1, 1) || {};
+			proto.support = {
+				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,
+				nativeBlendModes: BlendMode.nativeModes
+			};
+			CanvasProvider.release(ctx);
+		}
+		if (!this.agent) {
+			var user = self.navigator.userAgent.toLowerCase(),
+				os = (/(darwin|win|mac|linux|freebsd|sunos)/.exec(user)||[])[0],
+				platform = os === 'darwin' ? 'mac' : os,
+				agent = proto.agent = proto.browser = { platform: platform };
+			if (platform)
+				agent[platform] = true;
+			user.replace(
+				/(opera|chrome|safari|webkit|firefox|msie|trident|atom|node|jsdom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:v?([.\d]+))?/g,
+				function(match, n, v1, v2, rv) {
+					if (!agent.chrome) {
+						var v = n === 'opera' ? v2 :
+								/^(node|trident)$/.test(n) ? rv : v1;
+						agent.version = v;
+						agent.versionNumber = parseFloat(v);
+						n = { trident: 'msie', jsdom: 'node' }[n] || n;
+						agent.name = n;
+						agent[n] = true;
+					}
+				}
+			);
+			if (agent.chrome)
+				delete agent.webkit;
+			if (agent.atom)
+				delete agent.chrome;
+		}
+	},
+
+	version: "0.12.7",
+
+	getView: function() {
+		var project = this.project;
+		return project && project._view;
+	},
+
+	getPaper: function() {
+		return this;
+	},
+
+	execute: function(code, options) {
+			var exports = paper.PaperScript.execute(code, this, options);
+			View.updateFocus();
+			return exports;
+	},
+
+	install: function(scope) {
+		var that = this;
+		Base.each(['project', 'view', 'tool'], function(key) {
+			Base.define(scope, key, {
+				configurable: true,
+				get: function() {
+					return that[key];
+				}
+			});
+		});
+		for (var key in this)
+			if (!/^_/.test(key) && this[key])
+				scope[key] = this[key];
+	},
+
+	setup: function(element) {
+		paper = this;
+		this.project = new Project(element);
+		return this;
+	},
+
+	createCanvas: function(width, height) {
+		return CanvasProvider.getCanvas(width, height);
+	},
+
+	activate: function() {
+		paper = this;
+	},
+
+	clear: function() {
+		var projects = this.projects,
+			tools = this.tools;
+		for (var i = projects.length - 1; i >= 0; i--)
+			projects[i].remove();
+		for (var i = tools.length - 1; i >= 0; i--)
+			tools[i].remove();
+	},
+
+	remove: function() {
+		this.clear();
+		delete PaperScope._scopes[this._id];
+	},
+
+	statics: new function() {
+		function handleAttribute(name) {
+			name += 'Attribute';
+			return function(el, attr) {
+				return el[name](attr) || el[name]('data-paper-' + attr);
+			};
+		}
+
+		return {
+			_scopes: {},
+			_id: 0,
+
+			get: function(id) {
+				return this._scopes[id] || null;
+			},
+
+			getAttribute: handleAttribute('get'),
+			hasAttribute: handleAttribute('has')
+		};
+	}
+});
+
+var PaperScopeItem = Base.extend(Emitter, {
+
+	initialize: function(activate) {
+		this._scope = paper;
+		this._index = this._scope[this._list].push(this) - 1;
+		if (activate || !this._scope[this._reference])
+			this.activate();
+	},
+
+	activate: function() {
+		if (!this._scope)
+			return false;
+		var prev = this._scope[this._reference];
+		if (prev && prev !== this)
+			prev.emit('deactivate');
+		this._scope[this._reference] = this;
+		this.emit('activate', prev);
+		return true;
+	},
+
+	isActive: function() {
+		return this._scope[this._reference] === this;
+	},
+
+	remove: function() {
+		if (this._index == null)
+			return false;
+		Base.splice(this._scope[this._list], null, this._index, 1);
+		if (this._scope[this._reference] == this)
+			this._scope[this._reference] = null;
+		this._scope = null;
+		return true;
+	},
+
+	getView: function() {
+		return this._scope.getView();
+	}
+});
+
+var CollisionDetection = {
+	findItemBoundsCollisions: function(items1, items2, tolerance) {
+		function getBounds(items) {
+			var bounds = new Array(items.length);
+			for (var i = 0; i < items.length; i++) {
+				var rect = items[i].getBounds();
+				bounds[i] = [rect.left, rect.top, rect.right, rect.bottom];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(items1),
+			bounds2 = !items2 || items2 === items1
+				? bounds1
+				: getBounds(items2);
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findCurveBoundsCollisions: function(curves1, curves2, tolerance, bothAxis) {
+		function getBounds(curves) {
+			var min = Math.min,
+				max = Math.max,
+				bounds = new Array(curves.length);
+			for (var i = 0; i < curves.length; i++) {
+				var v = curves[i];
+				bounds[i] = [
+					min(v[0], v[2], v[4], v[6]),
+					min(v[1], v[3], v[5], v[7]),
+					max(v[0], v[2], v[4], v[6]),
+					max(v[1], v[3], v[5], v[7])
+				];
+			}
+			return bounds;
+		}
+
+		var bounds1 = getBounds(curves1),
+			bounds2 = !curves2 || curves2 === curves1
+				? bounds1
+				: getBounds(curves2);
+		if (bothAxis) {
+			var hor = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, false, true),
+				ver = this.findBoundsCollisions(
+					bounds1, bounds2, tolerance || 0, true, true),
+				list = [];
+			for (var i = 0, l = hor.length; i < l; i++) {
+				list[i] = { hor: hor[i], ver: ver[i] };
+			}
+			return list;
+		}
+		return this.findBoundsCollisions(bounds1, bounds2, tolerance || 0);
+	},
+
+	findBoundsCollisions: function(boundsA, boundsB, tolerance,
+		sweepVertical, onlySweepAxisCollisions) {
+		var self = !boundsB || boundsA === boundsB,
+			allBounds = self ? boundsA : boundsA.concat(boundsB),
+			lengthA = boundsA.length,
+			lengthAll = allBounds.length;
+
+		function binarySearch(indices, coord, value) {
+			var lo = 0,
+				hi = indices.length;
+			while (lo < hi) {
+				var mid = (hi + lo) >>> 1;
+				if (allBounds[indices[mid]][coord] < value) {
+					lo = mid + 1;
+				} else {
+					hi = mid;
+				}
+			}
+			return lo - 1;
+		}
+
+		var pri0 = sweepVertical ? 1 : 0,
+			pri1 = pri0 + 2,
+			sec0 = sweepVertical ? 0 : 1,
+			sec1 = sec0 + 2;
+		var allIndicesByPri0 = new Array(lengthAll);
+		for (var i = 0; i < lengthAll; i++) {
+			allIndicesByPri0[i] = i;
+		}
+		allIndicesByPri0.sort(function(i1, i2) {
+			return allBounds[i1][pri0] - allBounds[i2][pri0];
+		});
+		var activeIndicesByPri1 = [],
+			allCollisions = new Array(lengthA);
+		for (var i = 0; i < lengthAll; i++) {
+			var curIndex = allIndicesByPri0[i],
+				curBounds = allBounds[curIndex],
+				origIndex = self ? curIndex : curIndex - lengthA,
+				isCurrentA = curIndex < lengthA,
+				isCurrentB = self || !isCurrentA,
+				curCollisions = isCurrentA ? [] : null;
+			if (activeIndicesByPri1.length) {
+				var pruneCount = binarySearch(activeIndicesByPri1, pri1,
+						curBounds[pri0] - tolerance) + 1;
+				activeIndicesByPri1.splice(0, pruneCount);
+				if (self && onlySweepAxisCollisions) {
+					curCollisions = curCollisions.concat(activeIndicesByPri1);
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j];
+						allCollisions[activeIndex].push(origIndex);
+					}
+				} else {
+					var curSec1 = curBounds[sec1],
+						curSec0 = curBounds[sec0];
+					for (var j = 0; j < activeIndicesByPri1.length; j++) {
+						var activeIndex = activeIndicesByPri1[j],
+							activeBounds = allBounds[activeIndex],
+							isActiveA = activeIndex < lengthA,
+							isActiveB = self || activeIndex >= lengthA;
+
+						if (
+							onlySweepAxisCollisions ||
+							(
+								isCurrentA && isActiveB ||
+								isCurrentB && isActiveA
+							) && (
+								curSec1 >= activeBounds[sec0] - tolerance &&
+								curSec0 <= activeBounds[sec1] + tolerance
+							)
+						) {
+							if (isCurrentA && isActiveB) {
+								curCollisions.push(
+									self ? activeIndex : activeIndex - lengthA);
+							}
+							if (isCurrentB && isActiveA) {
+								allCollisions[activeIndex].push(origIndex);
+							}
+						}
+					}
+				}
+			}
+			if (isCurrentA) {
+				if (boundsA === boundsB) {
+					curCollisions.push(curIndex);
+				}
+				allCollisions[curIndex] = curCollisions;
+			}
+			if (activeIndicesByPri1.length) {
+				var curPri1 = curBounds[pri1],
+					index = binarySearch(activeIndicesByPri1, pri1, curPri1);
+				activeIndicesByPri1.splice(index + 1, 0, curIndex);
+			} else {
+				activeIndicesByPri1.push(curIndex);
+			}
+		}
+		for (var i = 0; i < allCollisions.length; i++) {
+			var collisions = allCollisions[i];
+			if (collisions) {
+				collisions.sort(function(i1, i2) { return i1 - i2; });
+			}
+		}
+		return allCollisions;
+	}
+};
+
+var Formatter = Base.extend({
+	initialize: function(precision) {
+		this.precision = Base.pick(precision, 5);
+		this.multiplier = Math.pow(10, this.precision);
+	},
+
+	number: function(val) {
+		return this.precision < 16
+				? Math.round(val * this.multiplier) / this.multiplier : val;
+	},
+
+	pair: function(val1, val2, separator) {
+		return this.number(val1) + (separator || ',') + this.number(val2);
+	},
+
+	point: function(val, separator) {
+		return this.number(val.x) + (separator || ',') + this.number(val.y);
+	},
+
+	size: function(val, separator) {
+		return this.number(val.width) + (separator || ',')
+				+ this.number(val.height);
+	},
+
+	rectangle: function(val, separator) {
+		return this.point(val, separator) + (separator || ',')
+				+ this.size(val, separator);
+	}
+});
+
+Formatter.instance = new Formatter();
+
+var Numerical = new function() {
+
+	var abscissas = [
+		[  0.5773502691896257645091488],
+		[0,0.7745966692414833770358531],
+		[  0.3399810435848562648026658,0.8611363115940525752239465],
+		[0,0.5384693101056830910363144,0.9061798459386639927976269],
+		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],
+		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],
+		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],
+		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],
+		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],
+		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],
+		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],
+		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],
+		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],
+		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],
+		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]
+	];
+
+	var weights = [
+		[1],
+		[0.8888888888888888888888889,0.5555555555555555555555556],
+		[0.6521451548625461426269361,0.3478548451374538573730639],
+		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],
+		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],
+		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],
+		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],
+		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],
+		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],
+		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],
+		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],
+		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],
+		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],
+		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],
+		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]
+	];
+
+	var abs = Math.abs,
+		sqrt = Math.sqrt,
+		pow = Math.pow,
+		log2 = Math.log2 || function(x) {
+			return Math.log(x) * Math.LOG2E;
+		},
+		EPSILON = 1e-12,
+		MACHINE_EPSILON = 1.12e-16;
+
+	function clamp(value, min, max) {
+		return value < min ? min : value > max ? max : value;
+	}
+
+	function getDiscriminant(a, b, c) {
+		function split(v) {
+			var x = v * 134217729,
+				y = v - x,
+				hi = y + x,
+				lo = v - hi;
+			return [hi, lo];
+		}
+
+		var D = b * b - a * c,
+			E = b * b + a * c;
+		if (abs(D) * 3 < E) {
+			var ad = split(a),
+				bd = split(b),
+				cd = split(c),
+				p = b * b,
+				dp = (bd[0] * bd[0] - p + 2 * bd[0] * bd[1]) + bd[1] * bd[1],
+				q = a * c,
+				dq = (ad[0] * cd[0] - q + ad[0] * cd[1] + ad[1] * cd[0])
+						+ ad[1] * cd[1];
+			D = (p - q) + (dp - dq);
+		}
+		return D;
+	}
+
+	function getNormalizationFactor() {
+		var norm = Math.max.apply(Math, arguments);
+		return norm && (norm < 1e-8 || norm > 1e8)
+				? pow(2, -Math.round(log2(norm)))
+				: 0;
+	}
+
+	return {
+		EPSILON: EPSILON,
+		MACHINE_EPSILON: MACHINE_EPSILON,
+		CURVETIME_EPSILON: 1e-8,
+		GEOMETRIC_EPSILON: 1e-7,
+		TRIGONOMETRIC_EPSILON: 1e-8,
+		KAPPA: 4 * (sqrt(2) - 1) / 3,
+
+		isZero: function(val) {
+			return val >= -EPSILON && val <= EPSILON;
+		},
+
+		isMachineZero: function(val) {
+			return val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;
+		},
+
+		clamp: clamp,
+
+		integrate: function(f, a, b, n) {
+			var x = abscissas[n - 2],
+				w = weights[n - 2],
+				A = (b - a) * 0.5,
+				B = A + a,
+				i = 0,
+				m = (n + 1) >> 1,
+				sum = n & 1 ? w[i++] * f(B) : 0;
+			while (i < m) {
+				var Ax = A * x[i];
+				sum += w[i++] * (f(B + Ax) + f(B - Ax));
+			}
+			return A * sum;
+		},
+
+		findRoot: function(f, df, x, a, b, n, tolerance) {
+			for (var i = 0; i < n; i++) {
+				var fx = f(x),
+					dx = fx / df(x),
+					nx = x - dx;
+				if (abs(dx) < tolerance) {
+					x = nx;
+					break;
+				}
+				if (fx > 0) {
+					b = x;
+					x = nx <= a ? (a + b) * 0.5 : nx;
+				} else {
+					a = x;
+					x = nx >= b ? (a + b) * 0.5 : nx;
+				}
+			}
+			return clamp(x, a, b);
+		},
+
+		solveQuadratic: function(a, b, c, roots, min, max) {
+			var x1, x2 = Infinity;
+			if (abs(a) < EPSILON) {
+				if (abs(b) < EPSILON)
+					return abs(c) < EPSILON ? -1 : 0;
+				x1 = -c / b;
+			} else {
+				b *= -0.5;
+				var D = getDiscriminant(a, b, c);
+				if (D && abs(D) < MACHINE_EPSILON) {
+					var f = getNormalizationFactor(abs(a), abs(b), abs(c));
+					if (f) {
+						a *= f;
+						b *= f;
+						c *= f;
+						D = getDiscriminant(a, b, c);
+					}
+				}
+				if (D >= -MACHINE_EPSILON) {
+					var Q = D < 0 ? 0 : sqrt(D),
+						R = b + (b < 0 ? -Q : Q);
+					if (R === 0) {
+						x1 = c / a;
+						x2 = -x1;
+					} else {
+						x1 = R / a;
+						x2 = c / R;
+					}
+				}
+			}
+			var count = 0,
+				boundless = min == null,
+				minB = min - EPSILON,
+				maxB = max + EPSILON;
+			if (isFinite(x1) && (boundless || x1 > minB && x1 < maxB))
+				roots[count++] = boundless ? x1 : clamp(x1, min, max);
+			if (x2 !== x1
+					&& isFinite(x2) && (boundless || x2 > minB && x2 < maxB))
+				roots[count++] = boundless ? x2 : clamp(x2, min, max);
+			return count;
+		},
+
+		solveCubic: function(a, b, c, d, roots, min, max) {
+			var f = getNormalizationFactor(abs(a), abs(b), abs(c), abs(d)),
+				x, b1, c2, qd, q;
+			if (f) {
+				a *= f;
+				b *= f;
+				c *= f;
+				d *= f;
+			}
+
+			function evaluate(x0) {
+				x = x0;
+				var tmp = a * x;
+				b1 = tmp + b;
+				c2 = b1 * x + c;
+				qd = (tmp + b1) * x + c2;
+				q = c2 * x + d;
+			}
+
+			if (abs(a) < EPSILON) {
+				a = b;
+				b1 = c;
+				c2 = d;
+				x = Infinity;
+			} else if (abs(d) < EPSILON) {
+				b1 = b;
+				c2 = c;
+				x = 0;
+			} else {
+				evaluate(-(b / a) / 3);
+				var t = q / a,
+					r = pow(abs(t), 1/3),
+					s = t < 0 ? -1 : 1,
+					td = -qd / a,
+					rd = td > 0 ? 1.324717957244746 * Math.max(r, sqrt(td)) : r,
+					x0 = x - s * rd;
+				if (x0 !== x) {
+					do {
+						evaluate(x0);
+						x0 = qd === 0 ? x : x - q / qd / (1 + MACHINE_EPSILON);
+					} while (s * x0 > s * x);
+					if (abs(a) * x * x > abs(d / x)) {
+						c2 = -d / x;
+						b1 = (c2 - c) / x;
+					}
+				}
+			}
+			var count = Numerical.solveQuadratic(a, b1, c2, roots, min, max),
+				boundless = min == null;
+			if (isFinite(x) && (count === 0
+					|| count > 0 && x !== roots[0] && x !== roots[1])
+					&& (boundless || x > min - EPSILON && x < max + EPSILON))
+				roots[count++] = boundless ? x : clamp(x, min, max);
+			return count;
+		}
+	};
+};
+
+var UID = {
+	_id: 1,
+	_pools: {},
+
+	get: function(name) {
+		if (name) {
+			var pool = this._pools[name];
+			if (!pool)
+				pool = this._pools[name] = { _id: 1 };
+			return pool._id++;
+		} else {
+			return this._id++;
+		}
+	}
+};
+
+var Point = Base.extend({
+	_class: 'Point',
+	_readIndex: true,
+
+	initialize: function Point(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasY = typeof arg1 === 'number';
+			this._set(arg0, hasY ? arg1 : arg0);
+			if (reading)
+				read = hasY ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('angle' in obj) {
+				this._set(obj.length || 0, 0);
+				this.setAngle(obj.angle || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y) {
+		this.x = x;
+		this.y = y;
+		return this;
+	},
+
+	equals: function(point) {
+		return this === point || point
+				&& (this.x === point.x && this.y === point.y
+					|| Array.isArray(point)
+						&& this.x === point[0] && this.y === point[1])
+				|| false;
+	},
+
+	clone: function() {
+		return new Point(this.x, this.y);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x), f.number(this.y)];
+	},
+
+	getLength: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	},
+
+	setLength: function(length) {
+		if (this.isZero()) {
+			var angle = this._angle || 0;
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		} else {
+			var scale = length / this.getLength();
+			if (Numerical.isZero(scale))
+				this.getAngle();
+			this._set(
+				this.x * scale,
+				this.y * scale
+			);
+		}
+	},
+	getAngle: function() {
+		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;
+	},
+
+	setAngle: function(angle) {
+		this.setAngleInRadians.call(this, angle * Math.PI / 180);
+	},
+
+	getAngleInDegrees: '#getAngle',
+	setAngleInDegrees: '#setAngle',
+
+	getAngleInRadians: function() {
+		if (!arguments.length) {
+			return this.isZero()
+					? this._angle || 0
+					: this._angle = Math.atan2(this.y, this.x);
+		} else {
+			var point = Point.read(arguments),
+				div = this.getLength() * point.getLength();
+			if (Numerical.isZero(div)) {
+				return NaN;
+			} else {
+				var a = this.dot(point) / div;
+				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);
+			}
+		}
+	},
+
+	setAngleInRadians: function(angle) {
+		this._angle = angle;
+		if (!this.isZero()) {
+			var length = this.getLength();
+			this._set(
+				Math.cos(angle) * length,
+				Math.sin(angle) * length
+			);
+		}
+	},
+
+	getQuadrant: function() {
+		return this.x >= 0 ? this.y >= 0 ? 1 : 4 : this.y >= 0 ? 2 : 3;
+	}
+}, {
+	beans: false,
+
+	getDirectedAngle: function() {
+		var point = Point.read(arguments);
+		return Math.atan2(this.cross(point), this.dot(point)) * 180 / Math.PI;
+	},
+
+	getDistance: function() {
+		var args = arguments,
+			point = Point.read(args),
+			x = point.x - this.x,
+			y = point.y - this.y,
+			d = x * x + y * y,
+			squared = Base.read(args);
+		return squared ? d : Math.sqrt(d);
+	},
+
+	normalize: function(length) {
+		if (length === undefined)
+			length = 1;
+		var current = this.getLength(),
+			scale = current !== 0 ? length / current : 0,
+			point = new Point(this.x * scale, this.y * scale);
+		if (scale >= 0)
+			point._angle = this._angle;
+		return point;
+	},
+
+	rotate: function(angle, center) {
+		if (angle === 0)
+			return this.clone();
+		angle = angle * Math.PI / 180;
+		var point = center ? this.subtract(center) : this,
+			sin = Math.sin(angle),
+			cos = Math.cos(angle);
+		point = new Point(
+			point.x * cos - point.y * sin,
+			point.x * sin + point.y * cos
+		);
+		return center ? point.add(center) : point;
+	},
+
+	transform: function(matrix) {
+		return matrix ? matrix._transformPoint(this) : this;
+	},
+
+	add: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x + point.x, this.y + point.y);
+	},
+
+	subtract: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x - point.x, this.y - point.y);
+	},
+
+	multiply: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x * point.x, this.y * point.y);
+	},
+
+	divide: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x / point.x, this.y / point.y);
+	},
+
+	modulo: function() {
+		var point = Point.read(arguments);
+		return new Point(this.x % point.x, this.y % point.y);
+	},
+
+	negate: function() {
+		return new Point(-this.x, -this.y);
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this);
+	},
+
+	isClose: function() {
+		var args = arguments,
+			point = Point.read(args),
+			tolerance = Base.read(args);
+		return this.getDistance(point) <= tolerance;
+	},
+
+	isCollinear: function() {
+		var point = Point.read(arguments);
+		return Point.isCollinear(this.x, this.y, point.x, point.y);
+	},
+
+	isColinear: '#isCollinear',
+
+	isOrthogonal: function() {
+		var point = Point.read(arguments);
+		return Point.isOrthogonal(this.x, this.y, point.x, point.y);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.x) && isZero(this.y);
+	},
+
+	isNaN: function() {
+		return isNaN(this.x) || isNaN(this.y);
+	},
+
+	isInQuadrant: function(q) {
+		return this.x * (q > 1 && q < 4 ? -1 : 1) >= 0
+			&& this.y * (q > 2 ? -1 : 1) >= 0;
+	},
+
+	dot: function() {
+		var point = Point.read(arguments);
+		return this.x * point.x + this.y * point.y;
+	},
+
+	cross: function() {
+		var point = Point.read(arguments);
+		return this.x * point.y - this.y * point.x;
+	},
+
+	project: function() {
+		var point = Point.read(arguments),
+			scale = point.isZero() ? 0 : this.dot(point) / point.dot(point);
+		return new Point(
+			point.x * scale,
+			point.y * scale
+		);
+	},
+
+	statics: {
+		min: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.min(point1.x, point2.x),
+				Math.min(point1.y, point2.y)
+			);
+		},
+
+		max: function() {
+			var args = arguments,
+				point1 = Point.read(args),
+				point2 = Point.read(args);
+			return new Point(
+				Math.max(point1.x, point2.x),
+				Math.max(point1.y, point2.y)
+			);
+		},
+
+		random: function() {
+			return new Point(Math.random(), Math.random());
+		},
+
+		isCollinear: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * y2 - y1 * x2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		},
+
+		isOrthogonal: function(x1, y1, x2, y2) {
+			return Math.abs(x1 * x2 + y1 * y2)
+					<= Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+						* 1e-8;
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Point(op(this.x), op(this.y));
+	};
+}, {}));
+
+var LinkedPoint = Point.extend({
+	initialize: function Point(x, y, owner, setter) {
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner[this._setter](this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner[this._setter](this);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		return this._setter === 'setPosition' ? 4 : 0;
+	}
+});
+
+var Size = Base.extend({
+	_class: 'Size',
+	_readIndex: true,
+
+	initialize: function Size(arg0, arg1) {
+		var type = typeof arg0,
+			reading = this.__read,
+			read = 0;
+		if (type === 'number') {
+			var hasHeight = typeof arg1 === 'number';
+			this._set(arg0, hasHeight ? arg1 : arg0);
+			if (reading)
+				read = hasHeight ? 2 : 1;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0);
+			if (reading)
+				read = arg0 === null ? 1 : 0;
+		} else {
+			var obj = type === 'string' ? arg0.split(/[\s,]+/) || [] : arg0;
+			read = 1;
+			if (Array.isArray(obj)) {
+				this._set(+obj[0], +(obj.length > 1 ? obj[1] : obj[0]));
+			} else if ('width' in obj) {
+				this._set(obj.width || 0, obj.height || 0);
+			} else if ('x' in obj) {
+				this._set(obj.x || 0, obj.y || 0);
+			} else {
+				this._set(0, 0);
+				read = 0;
+			}
+		}
+		if (reading)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(width, height) {
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	equals: function(size) {
+		return size === this || size && (this.width === size.width
+				&& this.height === size.height
+				|| Array.isArray(size) && this.width === size[0]
+					&& this.height === size[1]) || false;
+	},
+
+	clone: function() {
+		return new Size(this.width, this.height);
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height) + ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.width),
+				f.number(this.height)];
+	},
+
+	add: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width + size.width, this.height + size.height);
+	},
+
+	subtract: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width - size.width, this.height - size.height);
+	},
+
+	multiply: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width * size.width, this.height * size.height);
+	},
+
+	divide: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width / size.width, this.height / size.height);
+	},
+
+	modulo: function() {
+		var size = Size.read(arguments);
+		return new Size(this.width % size.width, this.height % size.height);
+	},
+
+	negate: function() {
+		return new Size(-this.width, -this.height);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this.width) && isZero(this.height);
+	},
+
+	isNaN: function() {
+		return isNaN(this.width) || isNaN(this.height);
+	},
+
+	statics: {
+		min: function(size1, size2) {
+			return new Size(
+				Math.min(size1.width, size2.width),
+				Math.min(size1.height, size2.height));
+		},
+
+		max: function(size1, size2) {
+			return new Size(
+				Math.max(size1.width, size2.width),
+				Math.max(size1.height, size2.height));
+		},
+
+		random: function() {
+			return new Size(Math.random(), Math.random());
+		}
+	}
+}, Base.each(['round', 'ceil', 'floor', 'abs'], function(key) {
+	var op = Math[key];
+	this[key] = function() {
+		return new Size(op(this.width), op(this.height));
+	};
+}, {}));
+
+var LinkedSize = Size.extend({
+	initialize: function Size(width, height, owner, setter) {
+		this._width = width;
+		this._height = height;
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(width, height, _dontNotify) {
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	},
+
+	getWidth: function() {
+		return this._width;
+	},
+
+	setWidth: function(width) {
+		this._width = width;
+		this._owner[this._setter](this);
+	},
+
+	getHeight: function() {
+		return this._height;
+	},
+
+	setHeight: function(height) {
+		this._height = height;
+		this._owner[this._setter](this);
+	}
+});
+
+var Rectangle = Base.extend({
+	_class: 'Rectangle',
+	_readIndex: true,
+	beans: true,
+
+	initialize: function Rectangle(arg0, arg1, arg2, arg3) {
+		var args = arguments,
+			type = typeof arg0,
+			read;
+		if (type === 'number') {
+			this._set(arg0, arg1, arg2, arg3);
+			read = 4;
+		} else if (type === 'undefined' || arg0 === null) {
+			this._set(0, 0, 0, 0);
+			read = arg0 === null ? 1 : 0;
+		} else if (args.length === 1) {
+			if (Array.isArray(arg0)) {
+				this._set.apply(this, arg0);
+				read = 1;
+			} else if (arg0.x !== undefined || arg0.width !== undefined) {
+				this._set(arg0.x || 0, arg0.y || 0,
+						arg0.width || 0, arg0.height || 0);
+				read = 1;
+			} else if (arg0.from === undefined && arg0.to === undefined) {
+				this._set(0, 0, 0, 0);
+				if (Base.readSupported(args, this)) {
+					read = 1;
+				}
+			}
+		}
+		if (read === undefined) {
+			var frm = Point.readNamed(args, 'from'),
+				next = Base.peek(args),
+				x = frm.x,
+				y = frm.y,
+				width,
+				height;
+			if (next && next.x !== undefined || Base.hasNamed(args, 'to')) {
+				var to = Point.readNamed(args, 'to');
+				width = to.x - x;
+				height = to.y - y;
+				if (width < 0) {
+					x = to.x;
+					width = -width;
+				}
+				if (height < 0) {
+					y = to.y;
+					height = -height;
+				}
+			} else {
+				var size = Size.read(args);
+				width = size.width;
+				height = size.height;
+			}
+			this._set(x, y, width, height);
+			read = args.__index;
+		}
+		var filtered = args.__filtered;
+		if (filtered)
+			this.__filtered = filtered;
+		if (this.__read)
+			this.__read = read;
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(x, y, width, height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		return this;
+	},
+
+	clone: function() {
+		return new Rectangle(this.x, this.y, this.width, this.height);
+	},
+
+	equals: function(rect) {
+		var rt = Base.isPlainValue(rect)
+				? Rectangle.read(arguments)
+				: rect;
+		return rt === this
+				|| rt && this.x === rt.x && this.y === rt.y
+					&& this.width === rt.width && this.height === rt.height
+				|| false;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '{ x: ' + f.number(this.x)
+				+ ', y: ' + f.number(this.y)
+				+ ', width: ' + f.number(this.width)
+				+ ', height: ' + f.number(this.height)
+				+ ' }';
+	},
+
+	_serialize: function(options) {
+		var f = options.formatter;
+		return [f.number(this.x),
+				f.number(this.y),
+				f.number(this.width),
+				f.number(this.height)];
+	},
+
+	getPoint: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.x, this.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.x = point.x;
+		this.y = point.y;
+	},
+
+	getSize: function(_dontLink) {
+		var ctor = _dontLink ? Size : LinkedSize;
+		return new ctor(this.width, this.height, this, 'setSize');
+	},
+
+	_fw: 1,
+	_fh: 1,
+
+	setSize: function() {
+		var size = Size.read(arguments),
+			sx = this._sx,
+			sy = this._sy,
+			w = size.width,
+			h = size.height;
+		if (sx) {
+			this.x += (this.width - w) * sx;
+		}
+		if (sy) {
+			this.y += (this.height - h) * sy;
+		}
+		this.width = w;
+		this.height = h;
+		this._fw = this._fh = 1;
+	},
+
+	getLeft: function() {
+		return this.x;
+	},
+
+	setLeft: function(left) {
+		if (!this._fw) {
+			var amount = left - this.x;
+			this.width -= this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = left;
+		this._sx = this._fw = 0;
+	},
+
+	getTop: function() {
+		return this.y;
+	},
+
+	setTop: function(top) {
+		if (!this._fh) {
+			var amount = top - this.y;
+			this.height -= this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = top;
+		this._sy = this._fh = 0;
+	},
+
+	getRight: function() {
+		return this.x + this.width;
+	},
+
+	setRight: function(right) {
+		if (!this._fw) {
+			var amount = right - this.x;
+			this.width = this._sx === 0.5 ? amount * 2 : amount;
+		}
+		this.x = right - this.width;
+		this._sx = 1;
+		this._fw = 0;
+	},
+
+	getBottom: function() {
+		return this.y + this.height;
+	},
+
+	setBottom: function(bottom) {
+		if (!this._fh) {
+			var amount = bottom - this.y;
+			this.height = this._sy === 0.5 ? amount * 2 : amount;
+		}
+		this.y = bottom - this.height;
+		this._sy = 1;
+		this._fh = 0;
+	},
+
+	getCenterX: function() {
+		return this.x + this.width / 2;
+	},
+
+	setCenterX: function(x) {
+		if (this._fw || this._sx === 0.5) {
+			this.x = x - this.width / 2;
+		} else {
+			if (this._sx) {
+				this.x += (x - this.x) * 2 * this._sx;
+			}
+			this.width = (x - this.x) * 2;
+		}
+		this._sx = 0.5;
+		this._fw = 0;
+	},
+
+	getCenterY: function() {
+		return this.y + this.height / 2;
+	},
+
+	setCenterY: function(y) {
+		if (this._fh || this._sy === 0.5) {
+			this.y = y - this.height / 2;
+		} else {
+			if (this._sy) {
+				this.y += (y - this.y) * 2 * this._sy;
+			}
+			this.height = (y - this.y) * 2;
+		}
+		this._sy = 0.5;
+		this._fh = 0;
+	},
+
+	getCenter: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		return new ctor(this.getCenterX(), this.getCenterY(), this, 'setCenter');
+	},
+
+	setCenter: function() {
+		var point = Point.read(arguments);
+		this.setCenterX(point.x);
+		this.setCenterY(point.y);
+		return this;
+	},
+
+	getArea: function() {
+		return this.width * this.height;
+	},
+
+	isEmpty: function() {
+		return this.width === 0 || this.height === 0;
+	},
+
+	contains: function(arg) {
+		return arg && arg.width !== undefined
+				|| (Array.isArray(arg) ? arg : arguments).length === 4
+				? this._containsRectangle(Rectangle.read(arguments))
+				: this._containsPoint(Point.read(arguments));
+	},
+
+	_containsPoint: function(point) {
+		var x = point.x,
+			y = point.y;
+		return x >= this.x && y >= this.y
+				&& x <= this.x + this.width
+				&& y <= this.y + this.height;
+	},
+
+	_containsRectangle: function(rect) {
+		var x = rect.x,
+			y = rect.y;
+		return x >= this.x && y >= this.y
+				&& x + rect.width <= this.x + this.width
+				&& y + rect.height <= this.y + this.height;
+	},
+
+	intersects: function() {
+		var rect = Rectangle.read(arguments),
+			epsilon = Base.read(arguments) || 0;
+		return rect.x + rect.width > this.x - epsilon
+				&& rect.y + rect.height > this.y - epsilon
+				&& rect.x < this.x + this.width + epsilon
+				&& rect.y < this.y + this.height + epsilon;
+	},
+
+	intersect: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.max(this.x, rect.x),
+			y1 = Math.max(this.y, rect.y),
+			x2 = Math.min(this.x + this.width, rect.x + rect.width),
+			y2 = Math.min(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	unite: function() {
+		var rect = Rectangle.read(arguments),
+			x1 = Math.min(this.x, rect.x),
+			y1 = Math.min(this.y, rect.y),
+			x2 = Math.max(this.x + this.width, rect.x + rect.width),
+			y2 = Math.max(this.y + this.height, rect.y + rect.height);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	include: function() {
+		var point = Point.read(arguments);
+		var x1 = Math.min(this.x, point.x),
+			y1 = Math.min(this.y, point.y),
+			x2 = Math.max(this.x + this.width, point.x),
+			y2 = Math.max(this.y + this.height, point.y);
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	},
+
+	expand: function() {
+		var amount = Size.read(arguments),
+			hor = amount.width,
+			ver = amount.height;
+		return new Rectangle(this.x - hor / 2, this.y - ver / 2,
+				this.width + hor, this.height + ver);
+	},
+
+	scale: function(hor, ver) {
+		return this.expand(this.width * hor - this.width,
+				this.height * (ver === undefined ? hor : ver) - this.height);
+	}
+}, Base.each([
+		['Top', 'Left'], ['Top', 'Right'],
+		['Bottom', 'Left'], ['Bottom', 'Right'],
+		['Left', 'Center'], ['Top', 'Center'],
+		['Right', 'Center'], ['Bottom', 'Center']
+	],
+	function(parts, index) {
+		var part = parts.join(''),
+			xFirst = /^[RL]/.test(part);
+		if (index >= 4)
+			parts[1] += xFirst ? 'Y' : 'X';
+		var x = parts[xFirst ? 0 : 1],
+			y = parts[xFirst ? 1 : 0],
+			getX = 'get' + x,
+			getY = 'get' + y,
+			setX = 'set' + x,
+			setY = 'set' + y,
+			get = 'get' + part,
+			set = 'set' + part;
+		this[get] = function(_dontLink) {
+			var ctor = _dontLink ? Point : LinkedPoint;
+			return new ctor(this[getX](), this[getY](), this, set);
+		};
+		this[set] = function() {
+			var point = Point.read(arguments);
+			this[setX](point.x);
+			this[setY](point.y);
+		};
+	}, {
+		beans: true
+	}
+));
+
+var LinkedRectangle = Rectangle.extend({
+	initialize: function Rectangle(x, y, width, height, owner, setter) {
+		this._set(x, y, width, height, true);
+		this._owner = owner;
+		this._setter = setter;
+	},
+
+	_set: function(x, y, width, height, _dontNotify) {
+		this._x = x;
+		this._y = y;
+		this._width = width;
+		this._height = height;
+		if (!_dontNotify)
+			this._owner[this._setter](this);
+		return this;
+	}
+},
+new function() {
+	var proto = Rectangle.prototype;
+
+	return Base.each(['x', 'y', 'width', 'height'], function(key) {
+		var part = Base.capitalize(key),
+			internal = '_' + key;
+		this['get' + part] = function() {
+			return this[internal];
+		};
+
+		this['set' + part] = function(value) {
+			this[internal] = value;
+			if (!this._dontNotify)
+				this._owner[this._setter](this);
+		};
+	}, Base.each(['Point', 'Size', 'Center',
+			'Left', 'Top', 'Right', 'Bottom', 'CenterX', 'CenterY',
+			'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+			'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'],
+		function(key) {
+			var name = 'set' + key;
+			this[name] = function() {
+				this._dontNotify = true;
+				proto[name].apply(this, arguments);
+				this._dontNotify = false;
+				this._owner[this._setter](this);
+			};
+		}, {
+			isSelected: function() {
+				return !!(this._owner._selection & 2);
+			},
+
+			setSelected: function(selected) {
+				var owner = this._owner;
+				if (owner._changeSelection) {
+					owner._changeSelection(2, selected);
+				}
+			}
+		})
+	);
+});
+
+var Matrix = Base.extend({
+	_class: 'Matrix',
+
+	initialize: function Matrix(arg, _dontNotify) {
+		var args = arguments,
+			count = args.length,
+			ok = true;
+		if (count >= 6) {
+			this._set.apply(this, args);
+		} else if (count === 1 || count === 2) {
+			if (arg instanceof Matrix) {
+				this._set(arg._a, arg._b, arg._c, arg._d, arg._tx, arg._ty,
+						_dontNotify);
+			} else if (Array.isArray(arg)) {
+				this._set.apply(this,
+						_dontNotify ? arg.concat([_dontNotify]) : arg);
+			} else {
+				ok = false;
+			}
+		} else if (!count) {
+			this.reset();
+		} else {
+			ok = false;
+		}
+		if (!ok) {
+			throw new Error('Unsupported matrix parameters');
+		}
+		return this;
+	},
+
+	set: '#initialize',
+
+	_set: function(a, b, c, d, tx, ty, _dontNotify) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+		this._tx = tx;
+		this._ty = ty;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.getValues(), options, true, dictionary);
+	},
+
+	_changed: function() {
+		var owner = this._owner;
+		if (owner) {
+			if (owner._applyMatrix) {
+				owner.transform(null, true);
+			} else {
+				owner._changed(25);
+			}
+		}
+	},
+
+	clone: function() {
+		return new Matrix(this._a, this._b, this._c, this._d,
+				this._tx, this._ty);
+	},
+
+	equals: function(mx) {
+		return mx === this || mx && this._a === mx._a && this._b === mx._b
+				&& this._c === mx._c && this._d === mx._d
+				&& this._tx === mx._tx && this._ty === mx._ty;
+	},
+
+	toString: function() {
+		var f = Formatter.instance;
+		return '[[' + [f.number(this._a), f.number(this._c),
+					f.number(this._tx)].join(', ') + '], ['
+				+ [f.number(this._b), f.number(this._d),
+					f.number(this._ty)].join(', ') + ']]';
+	},
+
+	reset: function(_dontNotify) {
+		this._a = this._d = 1;
+		this._b = this._c = this._tx = this._ty = 0;
+		if (!_dontNotify)
+			this._changed();
+		return this;
+	},
+
+	apply: function(recursively, _setApplyMatrix) {
+		var owner = this._owner;
+		if (owner) {
+			owner.transform(null, Base.pick(recursively, true), _setApplyMatrix);
+			return this.isIdentity();
+		}
+		return false;
+	},
+
+	translate: function() {
+		var point = Point.read(arguments),
+			x = point.x,
+			y = point.y;
+		this._tx += x * this._a + y * this._c;
+		this._ty += x * this._b + y * this._d;
+		this._changed();
+		return this;
+	},
+
+	scale: function() {
+		var args = arguments,
+			scale = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		this._a *= scale.x;
+		this._b *= scale.x;
+		this._c *= scale.y;
+		this._d *= scale.y;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	rotate: function(angle ) {
+		angle *= Math.PI / 180;
+		var center = Point.read(arguments, 1),
+			x = center.x,
+			y = center.y,
+			cos = Math.cos(angle),
+			sin = Math.sin(angle),
+			tx = x - x * cos + y * sin,
+			ty = y - x * sin - y * cos,
+			a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d;
+		this._a = cos * a + sin * c;
+		this._b = cos * b + sin * d;
+		this._c = -sin * a + cos * c;
+		this._d = -sin * b + cos * d;
+		this._tx += tx * a + ty * c;
+		this._ty += tx * b + ty * d;
+		this._changed();
+		return this;
+	},
+
+	shear: function() {
+		var args = arguments,
+			shear = Point.read(args),
+			center = Point.read(args, 0, { readNull: true });
+		if (center)
+			this.translate(center);
+		var a = this._a,
+			b = this._b;
+		this._a += shear.y * this._c;
+		this._b += shear.y * this._d;
+		this._c += shear.x * a;
+		this._d += shear.x * b;
+		if (center)
+			this.translate(center.negate());
+		this._changed();
+		return this;
+	},
+
+	skew: function() {
+		var args = arguments,
+			skew = Point.read(args),
+			center = Point.read(args, 0, { readNull: true }),
+			toRadians = Math.PI / 180,
+			shear = new Point(Math.tan(skew.x * toRadians),
+				Math.tan(skew.y * toRadians));
+		return this.shear(shear, center);
+	},
+
+	append: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + c2 * c1;
+			this._c = b2 * a1 + d2 * c1;
+			this._b = a2 * b1 + c2 * d1;
+			this._d = b2 * b1 + d2 * d1;
+			this._tx += tx2 * a1 + ty2 * c1;
+			this._ty += tx2 * b1 + ty2 * d1;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	prepend: function(mx, _dontNotify) {
+		if (mx) {
+			var a1 = this._a,
+				b1 = this._b,
+				c1 = this._c,
+				d1 = this._d,
+				tx1 = this._tx,
+				ty1 = this._ty,
+				a2 = mx._a,
+				b2 = mx._c,
+				c2 = mx._b,
+				d2 = mx._d,
+				tx2 = mx._tx,
+				ty2 = mx._ty;
+			this._a = a2 * a1 + b2 * b1;
+			this._c = a2 * c1 + b2 * d1;
+			this._b = c2 * a1 + d2 * b1;
+			this._d = c2 * c1 + d2 * d1;
+			this._tx = a2 * tx1 + b2 * ty1 + tx2;
+			this._ty = c2 * tx1 + d2 * ty1 + ty2;
+			if (!_dontNotify)
+				this._changed();
+		}
+		return this;
+	},
+
+	appended: function(mx) {
+		return this.clone().append(mx);
+	},
+
+	prepended: function(mx) {
+		return this.clone().prepend(mx);
+	},
+
+	invert: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			this._a = d / det;
+			this._b = -b / det;
+			this._c = -c / det;
+			this._d = a / det;
+			this._tx = (c * ty - d * tx) / det;
+			this._ty = (b * tx - a * ty) / det;
+			res = this;
+		}
+		return res;
+	},
+
+	inverted: function() {
+		return this.clone().invert();
+	},
+
+	concatenate: '#append',
+	preConcatenate: '#prepend',
+	chain: '#appended',
+
+	_shiftless: function() {
+		return new Matrix(this._a, this._b, this._c, this._d, 0, 0);
+	},
+
+	_orNullIfIdentity: function() {
+		return this.isIdentity() ? null : this;
+	},
+
+	isIdentity: function() {
+		return this._a === 1 && this._b === 0 && this._c === 0 && this._d === 1
+				&& this._tx === 0 && this._ty === 0;
+	},
+
+	isInvertible: function() {
+		var det = this._a * this._d - this._c * this._b;
+		return det && !isNaN(det) && isFinite(this._tx) && isFinite(this._ty);
+	},
+
+	isSingular: function() {
+		return !this.isInvertible();
+	},
+
+	transform: function( src, dst, count) {
+		return arguments.length < 3
+			? this._transformPoint(Point.read(arguments))
+			: this._transformCoordinates(src, dst, count);
+	},
+
+	_transformPoint: function(point, dest, _dontNotify) {
+		var x = point.x,
+			y = point.y;
+		if (!dest)
+			dest = new Point();
+		return dest._set(
+				x * this._a + y * this._c + this._tx,
+				x * this._b + y * this._d + this._ty,
+				_dontNotify);
+	},
+
+	_transformCoordinates: function(src, dst, count) {
+		for (var i = 0, max = 2 * count; i < max; i += 2) {
+			var x = src[i],
+				y = src[i + 1];
+			dst[i] = x * this._a + y * this._c + this._tx;
+			dst[i + 1] = x * this._b + y * this._d + this._ty;
+		}
+		return dst;
+	},
+
+	_transformCorners: function(rect) {
+		var x1 = rect.x,
+			y1 = rect.y,
+			x2 = x1 + rect.width,
+			y2 = y1 + rect.height,
+			coords = [ x1, y1, x2, y1, x2, y2, x1, y2 ];
+		return this._transformCoordinates(coords, coords, 4);
+	},
+
+	_transformBounds: function(bounds, dest, _dontNotify) {
+		var coords = this._transformCorners(bounds),
+			min = coords.slice(0, 2),
+			max = min.slice();
+		for (var i = 2; i < 8; i++) {
+			var val = coords[i],
+				j = i & 1;
+			if (val < min[j]) {
+				min[j] = val;
+			} else if (val > max[j]) {
+				max[j] = val;
+			}
+		}
+		if (!dest)
+			dest = new Rectangle();
+		return dest._set(min[0], min[1], max[0] - min[0], max[1] - min[1],
+				_dontNotify);
+	},
+
+	inverseTransform: function() {
+		return this._inverseTransform(Point.read(arguments));
+	},
+
+	_inverseTransform: function(point, dest, _dontNotify) {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			tx = this._tx,
+			ty = this._ty,
+			det = a * d - b * c,
+			res = null;
+		if (det && !isNaN(det) && isFinite(tx) && isFinite(ty)) {
+			var x = point.x - this._tx,
+				y = point.y - this._ty;
+			if (!dest)
+				dest = new Point();
+			res = dest._set(
+					(x * d - y * c) / det,
+					(y * a - x * b) / det,
+					_dontNotify);
+		}
+		return res;
+	},
+
+	decompose: function() {
+		var a = this._a,
+			b = this._b,
+			c = this._c,
+			d = this._d,
+			det = a * d - b * c,
+			sqrt = Math.sqrt,
+			atan2 = Math.atan2,
+			degrees = 180 / Math.PI,
+			rotate,
+			scale,
+			skew;
+		if (a !== 0 || b !== 0) {
+			var r = sqrt(a * a + b * b);
+			rotate = Math.acos(a / r) * (b > 0 ? 1 : -1);
+			scale = [r, det / r];
+			skew = [atan2(a * c + b * d, r * r), 0];
+		} else if (c !== 0 || d !== 0) {
+			var s = sqrt(c * c + d * d);
+			rotate = Math.asin(c / s)  * (d > 0 ? 1 : -1);
+			scale = [det / s, s];
+			skew = [0, atan2(a * c + b * d, s * s)];
+		} else {
+			rotate = 0;
+			skew = scale = [0, 0];
+		}
+		return {
+			translation: this.getTranslation(),
+			rotation: rotate * degrees,
+			scaling: new Point(scale),
+			skewing: new Point(skew[0] * degrees, skew[1] * degrees)
+		};
+	},
+
+	getValues: function() {
+		return [ this._a, this._b, this._c, this._d, this._tx, this._ty ];
+	},
+
+	getTranslation: function() {
+		return new Point(this._tx, this._ty);
+	},
+
+	getScaling: function() {
+		return this.decompose().scaling;
+	},
+
+	getRotation: function() {
+		return this.decompose().rotation;
+	},
+
+	applyToContext: function(ctx) {
+		if (!this.isIdentity()) {
+			ctx.transform(this._a, this._b, this._c, this._d,
+					this._tx, this._ty);
+		}
+	}
+}, Base.each(['a', 'b', 'c', 'd', 'tx', 'ty'], function(key) {
+	var part = Base.capitalize(key),
+		prop = '_' + key;
+	this['get' + part] = function() {
+		return this[prop];
+	};
+	this['set' + part] = function(value) {
+		this[prop] = value;
+		this._changed();
+	};
+}, {}));
+
+var Line = Base.extend({
+	_class: 'Line',
+
+	initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
+		var asVector = false;
+		if (arguments.length >= 4) {
+			this._px = arg0;
+			this._py = arg1;
+			this._vx = arg2;
+			this._vy = arg3;
+			asVector = arg4;
+		} else {
+			this._px = arg0.x;
+			this._py = arg0.y;
+			this._vx = arg1.x;
+			this._vy = arg1.y;
+			asVector = arg2;
+		}
+		if (!asVector) {
+			this._vx -= this._px;
+			this._vy -= this._py;
+		}
+	},
+
+	getPoint: function() {
+		return new Point(this._px, this._py);
+	},
+
+	getVector: function() {
+		return new Point(this._vx, this._vy);
+	},
+
+	getLength: function() {
+		return this.getVector().getLength();
+	},
+
+	intersect: function(line, isInfinite) {
+		return Line.intersect(
+				this._px, this._py, this._vx, this._vy,
+				line._px, line._py, line._vx, line._vy,
+				true, isInfinite);
+	},
+
+	getSide: function(point, isInfinite) {
+		return Line.getSide(
+				this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true, isInfinite);
+	},
+
+	getDistance: function(point) {
+		return Math.abs(this.getSignedDistance(point));
+	},
+
+	getSignedDistance: function(point) {
+		return Line.getSignedDistance(this._px, this._py, this._vx, this._vy,
+				point.x, point.y, true);
+	},
+
+	isCollinear: function(line) {
+		return Point.isCollinear(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	isOrthogonal: function(line) {
+		return Point.isOrthogonal(this._vx, this._vy, line._vx, line._vy);
+	},
+
+	statics: {
+		intersect: function(p1x, p1y, v1x, v1y, p2x, p2y, v2x, v2y, asVector,
+				isInfinite) {
+			if (!asVector) {
+				v1x -= p1x;
+				v1y -= p1y;
+				v2x -= p2x;
+				v2y -= p2y;
+			}
+			var cross = v1x * v2y - v1y * v2x;
+			if (!Numerical.isMachineZero(cross)) {
+				var dx = p1x - p2x,
+					dy = p1y - p2y,
+					u1 = (v2x * dy - v2y * dx) / cross,
+					u2 = (v1x * dy - v1y * dx) / cross,
+					epsilon = 1e-12,
+					uMin = -epsilon,
+					uMax = 1 + epsilon;
+				if (isInfinite
+						|| uMin < u1 && u1 < uMax && uMin < u2 && u2 < uMax) {
+					if (!isInfinite) {
+						u1 = u1 <= 0 ? 0 : u1 >= 1 ? 1 : u1;
+					}
+					return new Point(
+							p1x + u1 * v1x,
+							p1y + u1 * v1y);
+				}
+			}
+		},
+
+		getSide: function(px, py, vx, vy, x, y, asVector, isInfinite) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			var v2x = x - px,
+				v2y = y - py,
+				ccw = v2x * vy - v2y * vx;
+			if (!isInfinite && Numerical.isMachineZero(ccw)) {
+				ccw = (v2x * vx + v2x * vx) / (vx * vx + vy * vy);
+				if (ccw >= 0 && ccw <= 1)
+					ccw = 0;
+			}
+			return ccw < 0 ? -1 : ccw > 0 ? 1 : 0;
+		},
+
+		getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
+			if (!asVector) {
+				vx -= px;
+				vy -= py;
+			}
+			  return  vx === 0 ? (vy > 0 ? x - px : px - x)
+					: vy === 0 ? (vx < 0 ? y - py : py - y)
+					: ((x - px) * vy - (y - py) * vx) / (
+						vy > vx
+							? vy * Math.sqrt(1 + (vx * vx) / (vy * vy))
+							: vx * Math.sqrt(1 + (vy * vy) / (vx * vx))
+					);
+		},
+
+		getDistance: function(px, py, vx, vy, x, y, asVector) {
+			return Math.abs(
+					Line.getSignedDistance(px, py, vx, vy, x, y, asVector));
+		}
+	}
+});
+
+var Project = PaperScopeItem.extend({
+	_class: 'Project',
+	_list: 'projects',
+	_reference: 'project',
+	_compactSerialize: true,
+
+	initialize: function Project(element) {
+		PaperScopeItem.call(this, true);
+		this._children = [];
+		this._namedChildren = {};
+		this._activeLayer = null;
+		this._currentStyle = new Style(null, null, this);
+		this._view = View.create(this,
+				element || CanvasProvider.getCanvas(1, 1));
+		this._selectionItems = {};
+		this._selectionCount = 0;
+		this._updateVersion = 0;
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this._children, options, true, dictionary);
+	},
+
+	_changed: function(flags, item) {
+		if (flags & 1) {
+			var view = this._view;
+			if (view) {
+				view._needsUpdate = true;
+				if (!view._requested && view._autoUpdate)
+					view.requestUpdate();
+			}
+		}
+		var changes = this._changes;
+		if (changes && item) {
+			var changesById = this._changesById,
+				id = item._id,
+				entry = changesById[id];
+			if (entry) {
+				entry.flags |= flags;
+			} else {
+				changes.push(changesById[id] = { item: item, flags: flags });
+			}
+		}
+	},
+
+	clear: function() {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--)
+			children[i].remove();
+	},
+
+	isEmpty: function() {
+		return !this._children.length;
+	},
+
+	remove: function remove() {
+		if (!remove.base.call(this))
+			return false;
+		if (this._view)
+			this._view.remove();
+		return true;
+	},
+
+	getView: function() {
+		return this._view;
+	},
+
+	getCurrentStyle: function() {
+		return this._currentStyle;
+	},
+
+	setCurrentStyle: function(style) {
+		this._currentStyle.set(style);
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	getOptions: function() {
+		return this._scope.settings;
+	},
+
+	getLayers: function() {
+		return this._children;
+	},
+
+	getActiveLayer: function() {
+		return this._activeLayer || new Layer({ project: this, insert: true });
+	},
+
+	getSymbolDefinitions: function() {
+		var definitions = [],
+			ids = {};
+		this.getItems({
+			class: SymbolItem,
+			match: function(item) {
+				var definition = item._definition,
+					id = definition._id;
+				if (!ids[id]) {
+					ids[id] = true;
+					definitions.push(definition);
+				}
+				return false;
+			}
+		});
+		return definitions;
+	},
+
+	getSymbols: 'getSymbolDefinitions',
+
+	getSelectedItems: function() {
+		var selectionItems = this._selectionItems,
+			items = [];
+		for (var id in selectionItems) {
+			var item = selectionItems[id],
+				selection = item._selection;
+			if ((selection & 1) && item.isInserted()) {
+				items.push(item);
+			} else if (!selection) {
+				this._updateSelection(item);
+			}
+		}
+		return items;
+	},
+
+	_updateSelection: function(item) {
+		var id = item._id,
+			selectionItems = this._selectionItems;
+		if (item._selection) {
+			if (selectionItems[id] !== item) {
+				this._selectionCount++;
+				selectionItems[id] = item;
+			}
+		} else if (selectionItems[id] === item) {
+			this._selectionCount--;
+			delete selectionItems[id];
+		}
+	},
+
+	selectAll: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].setFullySelected(true);
+	},
+
+	deselectAll: function() {
+		var selectionItems = this._selectionItems;
+		for (var i in selectionItems)
+			selectionItems[i].setFullySelected(false);
+	},
+
+	addLayer: function(layer) {
+		return this.insertLayer(undefined, layer);
+	},
+
+	insertLayer: function(index, layer) {
+		if (layer instanceof Layer) {
+			layer._remove(false, true);
+			Base.splice(this._children, [layer], index, 0);
+			layer._setProject(this, true);
+			var name = layer._name;
+			if (name)
+				layer.setName(name);
+			if (this._changes)
+				layer._changed(5);
+			if (!this._activeLayer)
+				this._activeLayer = layer;
+		} else {
+			layer = null;
+		}
+		return layer;
+	},
+
+	_insertItem: function(index, item, _created) {
+		item = this.insertLayer(index, item)
+				|| (this._activeLayer || this._insertItem(undefined,
+						new Layer(Item.NO_INSERT), true))
+						.insertChild(index, item);
+		if (_created && item.activate)
+			item.activate();
+		return item;
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, null, null, true)[0] || null;
+	},
+
+	importJSON: function(json) {
+		this.activate();
+		var layer = this._activeLayer;
+		return Base.importJSON(json, layer && layer.isEmpty() && layer);
+	},
+
+	removeOn: function(type) {
+		var sets = this._removeSets;
+		if (sets) {
+			if (type === 'mouseup')
+				sets.mousedrag = null;
+			var set = sets[type];
+			if (set) {
+				for (var id in set) {
+					var item = set[id];
+					for (var key in sets) {
+						var other = sets[key];
+						if (other && other != set)
+							delete other[item._id];
+					}
+					item.remove();
+				}
+				sets[type] = null;
+			}
+		}
+	},
+
+	draw: function(ctx, matrix, pixelRatio) {
+		this._updateVersion++;
+		ctx.save();
+		matrix.applyToContext(ctx);
+		var children = this._children,
+			param = new Base({
+				offset: new Point(0, 0),
+				pixelRatio: pixelRatio,
+				viewMatrix: matrix.isIdentity() ? null : matrix,
+				matrices: [new Matrix()],
+				updateMatrix: true
+			});
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].draw(ctx, param);
+		}
+		ctx.restore();
+
+		if (this._selectionCount > 0) {
+			ctx.save();
+			ctx.strokeWidth = 1;
+			var items = this._selectionItems,
+				size = this._scope.settings.handleSize,
+				version = this._updateVersion;
+			for (var id in items) {
+				items[id]._drawSelection(ctx, matrix, size, items, version);
+			}
+			ctx.restore();
+		}
+	}
+});
+
+var Item = Base.extend(Emitter, {
+	statics: {
+		extend: function extend(src) {
+			if (src._serializeFields)
+				src._serializeFields = Base.set({},
+					this.prototype._serializeFields, src._serializeFields);
+			return extend.base.apply(this, arguments);
+		},
+
+		NO_INSERT: { insert: false }
+	},
+
+	_class: 'Item',
+	_name: null,
+	_applyMatrix: true,
+	_canApplyMatrix: true,
+	_canScaleStroke: false,
+	_pivot: null,
+	_visible: true,
+	_blendMode: 'normal',
+	_opacity: 1,
+	_locked: false,
+	_guide: false,
+	_clipMask: false,
+	_selection: 0,
+	_selectBounds: true,
+	_selectChildren: false,
+	_serializeFields: {
+		name: null,
+		applyMatrix: null,
+		matrix: new Matrix(),
+		pivot: null,
+		visible: true,
+		blendMode: 'normal',
+		opacity: 1,
+		locked: false,
+		guide: false,
+		clipMask: false,
+		selected: false,
+		data: {}
+	},
+	_prioritize: ['applyMatrix']
+},
+new function() {
+	var handlers = ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onClick',
+			'onDoubleClick', 'onMouseMove', 'onMouseEnter', 'onMouseLeave'];
+	return Base.each(handlers,
+		function(name) {
+			this._events[name] = {
+				install: function(type) {
+					this.getView()._countItemEvent(type, 1);
+				},
+
+				uninstall: function(type) {
+					this.getView()._countItemEvent(type, -1);
+				}
+			};
+		}, {
+			_events: {
+				onFrame: {
+					install: function() {
+						this.getView()._animateItem(this, true);
+					},
+
+					uninstall: function() {
+						this.getView()._animateItem(this, false);
+					}
+				},
+
+				onLoad: {},
+				onError: {}
+			},
+			statics: {
+				_itemHandlers: handlers
+			}
+		}
+	);
+}, {
+	initialize: function Item() {
+	},
+
+	_initialize: function(props, point) {
+		var hasProps = props && Base.isPlainObject(props),
+			internal = hasProps && props.internal === true,
+			matrix = this._matrix = new Matrix(),
+			project = hasProps && props.project || paper.project,
+			settings = paper.settings;
+		this._id = internal ? null : UID.get();
+		this._parent = this._index = null;
+		this._applyMatrix = this._canApplyMatrix && settings.applyMatrix;
+		if (point)
+			matrix.translate(point);
+		matrix._owner = this;
+		this._style = new Style(project._currentStyle, this, project);
+		if (internal || hasProps && props.insert == false
+			|| !settings.insertItems && !(hasProps && props.insert === true)) {
+			this._setProject(project);
+		} else {
+			(hasProps && props.parent || project)
+					._insertItem(undefined, this, true);
+		}
+		if (hasProps && props !== Item.NO_INSERT) {
+			this.set(props, {
+				internal: true, insert: true, project: true, parent: true
+			});
+		}
+		return hasProps;
+	},
+
+	_serialize: function(options, dictionary) {
+		var props = {},
+			that = this;
+
+		function serialize(fields) {
+			for (var key in fields) {
+				var value = that[key];
+				if (!Base.equals(value, key === 'leading'
+						? fields.fontSize * 1.2 : fields[key])) {
+					props[key] = Base.serialize(value, options,
+							key !== 'data', dictionary);
+				}
+			}
+		}
+
+		serialize(this._serializeFields);
+		if (!(this instanceof Group))
+			serialize(this._style._defaults);
+		return [ this._class, props ];
+	},
+
+	_changed: function(flags) {
+		var symbol = this._symbol,
+			cacheParent = this._parent || symbol,
+			project = this._project;
+		if (flags & 8) {
+			this._bounds = this._position = this._decomposed = undefined;
+		}
+		if (flags & 16) {
+			this._globalMatrix = undefined;
+		}
+		if (cacheParent
+				&& (flags & 72)) {
+			Item._clearBoundsCache(cacheParent);
+		}
+		if (flags & 2) {
+			Item._clearBoundsCache(this);
+		}
+		if (project)
+			project._changed(flags, this);
+		if (symbol)
+			symbol._changed(flags);
+	},
+
+	getId: function() {
+		return this._id;
+	},
+
+	getName: function() {
+		return this._name;
+	},
+
+	setName: function(name) {
+
+		if (this._name)
+			this._removeNamed();
+		if (name === (+name) + '')
+			throw new Error(
+					'Names consisting only of numbers are not supported.');
+		var owner = this._getOwner();
+		if (name && owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren;
+			(namedChildren[name] = namedChildren[name] || []).push(this);
+			if (!(name in children))
+				children[name] = this;
+		}
+		this._name = name || undefined;
+		this._changed(256);
+	},
+
+	getStyle: function() {
+		return this._style;
+	},
+
+	setStyle: function(style) {
+		this.getStyle().set(style);
+	}
+}, Base.each(['locked', 'visible', 'blendMode', 'opacity', 'guide'],
+	function(name) {
+		var part = Base.capitalize(name),
+			key = '_' + name,
+			flags = {
+				locked: 256,
+				visible: 265
+			};
+		this['get' + part] = function() {
+			return this[key];
+		};
+		this['set' + part] = function(value) {
+			if (value != this[key]) {
+				this[key] = value;
+				this._changed(flags[name] || 257);
+			}
+		};
+	},
+{}), {
+	beans: true,
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		if (selection !== this._selection) {
+			this._selection = selection;
+			var project = this._project;
+			if (project) {
+				project._updateSelection(this);
+				this._changed(257);
+			}
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				if (children[i].isSelected())
+					return true;
+		}
+		return !!(this._selection & 1);
+	},
+
+	setSelected: function(selected) {
+		if (this._selectChildren) {
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setSelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isFullySelected: function() {
+		var children = this._children,
+			selected = !!(this._selection & 1);
+		if (children && selected) {
+			for (var i = 0, l = children.length; i < l; i++)
+				if (!children[i].isFullySelected())
+					return false;
+			return true;
+		}
+		return selected;
+	},
+
+	setFullySelected: function(selected) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++)
+				children[i].setFullySelected(selected);
+		}
+		this._changeSelection(1, selected);
+	},
+
+	isClipMask: function() {
+		return this._clipMask;
+	},
+
+	setClipMask: function(clipMask) {
+		if (this._clipMask != (clipMask = !!clipMask)) {
+			this._clipMask = clipMask;
+			if (clipMask) {
+				this.setFillColor(null);
+				this.setStrokeColor(null);
+			}
+			this._changed(257);
+			if (this._parent)
+				this._parent._changed(2048);
+		}
+	},
+
+	getData: function() {
+		if (!this._data)
+			this._data = {};
+		return this._data;
+	},
+
+	setData: function(data) {
+		this._data = data;
+	},
+
+	getPosition: function(_dontLink) {
+		var ctor = _dontLink ? Point : LinkedPoint;
+		var position = this._position ||
+			(this._position = this._getPositionFromBounds());
+		return new ctor(position.x, position.y, this, 'setPosition');
+	},
+
+	setPosition: function() {
+		this.translate(Point.read(arguments).subtract(this.getPosition(true)));
+	},
+
+	_getPositionFromBounds: function(bounds) {
+		return this._pivot
+				? this._matrix._transformPoint(this._pivot)
+				: (bounds || this.getBounds()).getCenter(true);
+	},
+
+	getPivot: function() {
+		var pivot = this._pivot;
+		return pivot
+				? new LinkedPoint(pivot.x, pivot.y, this, 'setPivot')
+				: null;
+	},
+
+	setPivot: function() {
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
+		this._position = undefined;
+	}
+}, Base.each({
+		getStrokeBounds: { stroke: true },
+		getHandleBounds: { handle: true },
+		getInternalBounds: { internal: true }
+	},
+	function(options, key) {
+		this[key] = function(matrix) {
+			return this.getBounds(matrix, options);
+		};
+	},
+{
+	beans: true,
+
+	getBounds: function(matrix, options) {
+		var hasMatrix = options || matrix instanceof Matrix,
+			opts = Base.set({}, hasMatrix ? options : matrix,
+					this._boundsOptions);
+		if (!opts.stroke || this.getStrokeScaling())
+			opts.cacheItem = this;
+		var rect = this._getCachedBounds(hasMatrix && matrix, opts).rect;
+		return !arguments.length
+				? new LinkedRectangle(rect.x, rect.y, rect.width, rect.height,
+					this, 'setBounds')
+				: rect;
+	},
+
+	setBounds: function() {
+		var rect = Rectangle.read(arguments),
+			bounds = this.getBounds(),
+			_matrix = this._matrix,
+			matrix = new Matrix(),
+			center = rect.getCenter();
+		matrix.translate(center);
+		if (rect.width != bounds.width || rect.height != bounds.height) {
+			if (!_matrix.isInvertible()) {
+				_matrix.set(_matrix._backup
+						|| new Matrix().translate(_matrix.getTranslation()));
+				bounds = this.getBounds();
+			}
+			matrix.scale(
+					bounds.width !== 0 ? rect.width / bounds.width : 0,
+					bounds.height !== 0 ? rect.height / bounds.height : 0);
+		}
+		center = bounds.getCenter();
+		matrix.translate(-center.x, -center.y);
+		this.transform(matrix);
+	},
+
+	_getBounds: function(matrix, options) {
+		var children = this._children;
+		if (!children || !children.length)
+			return new Rectangle();
+		Item._updateBoundsCache(this, options.cacheItem);
+		return Item._getBounds(children, matrix, options);
+	},
+
+	_getBoundsCacheKey: function(options, internal) {
+		return [
+			options.stroke ? 1 : 0,
+			options.handle ? 1 : 0,
+			internal ? 1 : 0
+		].join('');
+	},
+
+	_getCachedBounds: function(matrix, options, noInternal) {
+		matrix = matrix && matrix._orNullIfIdentity();
+		var internal = options.internal && !noInternal,
+			cacheItem = options.cacheItem,
+			_matrix = internal ? null : this._matrix._orNullIfIdentity(),
+			cacheKey = cacheItem && (!matrix || matrix.equals(_matrix))
+				&& this._getBoundsCacheKey(options, internal),
+			bounds = this._bounds;
+		Item._updateBoundsCache(this._parent || this._symbol, cacheItem);
+		if (cacheKey && bounds && cacheKey in bounds) {
+			var cached = bounds[cacheKey];
+			return {
+				rect: cached.rect.clone(),
+				nonscaling: cached.nonscaling
+			};
+		}
+		var res = this._getBounds(matrix || _matrix, options),
+			rect = res.rect || res,
+			style = this._style,
+			nonscaling = res.nonscaling || style.hasStroke()
+				&& !style.getStrokeScaling();
+		if (cacheKey) {
+			if (!bounds) {
+				this._bounds = bounds = {};
+			}
+			var cached = bounds[cacheKey] = {
+				rect: rect.clone(),
+				nonscaling: nonscaling,
+				internal: internal
+			};
+		}
+		return {
+			rect: rect,
+			nonscaling: nonscaling
+		};
+	},
+
+	_getStrokeMatrix: function(matrix, options) {
+		var parent = this.getStrokeScaling() ? null
+				: options && options.internal ? this
+					: this._parent || this._symbol && this._symbol._item,
+			mx = parent ? parent.getViewMatrix().invert() : matrix;
+		return mx && mx._shiftless();
+	},
+
+	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent && item) {
+				var id = item._id,
+					ref = parent._boundsCache = parent._boundsCache || {
+						ids: {},
+						list: []
+					};
+				if (!ref.ids[id]) {
+					ref.list.push(item);
+					ref.ids[id] = item;
+				}
+			}
+		},
+
+		_clearBoundsCache: function(item) {
+			var cache = item._boundsCache;
+			if (cache) {
+				item._bounds = item._position = item._boundsCache = undefined;
+				for (var i = 0, list = cache.list, l = list.length; i < l; i++){
+					var other = list[i];
+					if (other !== item) {
+						other._bounds = other._position = undefined;
+						if (other._boundsCache)
+							Item._clearBoundsCache(other);
+					}
+				}
+			}
+		},
+
+		_getBounds: function(items, matrix, options) {
+			var x1 = Infinity,
+				x2 = -x1,
+				y1 = x1,
+				y2 = x2,
+				nonscaling = false;
+			options = options || {};
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i];
+				if (item._visible && !item.isEmpty(true)) {
+					var bounds = item._getCachedBounds(
+						matrix && matrix.appended(item._matrix), options, true),
+						rect = bounds.rect;
+					x1 = Math.min(rect.x, x1);
+					y1 = Math.min(rect.y, y1);
+					x2 = Math.max(rect.x + rect.width, x2);
+					y2 = Math.max(rect.y + rect.height, y2);
+					if (bounds.nonscaling)
+						nonscaling = true;
+				}
+			}
+			return {
+				rect: isFinite(x1)
+					? new Rectangle(x1, y1, x2 - x1, y2 - y1)
+					: new Rectangle(),
+				nonscaling: nonscaling
+			};
+		}
+	}
+
+}), {
+	beans: true,
+
+	_decompose: function() {
+		return this._applyMatrix
+			? null
+			: this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	getRotation: function() {
+		var decomposed = this._decompose();
+		return decomposed ? decomposed.rotation : 0;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			var decomposed = this._decomposed;
+			this.rotate(rotation - current);
+			if (decomposed) {
+				decomposed.rotation = rotation;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getScaling: function() {
+		var decomposed = this._decompose(),
+			s = decomposed && decomposed.scaling;
+		return new LinkedPoint(s ? s.x : 1, s ? s.y : 1, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling && !current.equals(scaling)) {
+			var rotation = this.getRotation(),
+				decomposed = this._decomposed,
+				matrix = new Matrix(),
+				center = this.getPosition(true);
+			matrix.translate(center);
+			if (rotation)
+				matrix.rotate(rotation);
+			matrix.scale(scaling.x / current.x, scaling.y / current.y);
+			if (rotation)
+				matrix.rotate(-rotation);
+			matrix.translate(center.negate());
+			this.transform(matrix);
+			if (decomposed) {
+				decomposed.scaling = scaling;
+				this._decomposed = decomposed;
+			}
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	getGlobalMatrix: function(_dontClone) {
+		var matrix = this._globalMatrix;
+		if (matrix) {
+			var parent = this._parent;
+			var parents = [];
+			while (parent) {
+				if (!parent._globalMatrix) {
+					matrix = null;
+					for (var i = 0, l = parents.length; i < l; i++) {
+						parents[i]._globalMatrix = null;
+					}
+					break;
+				}
+				parents.push(parent);
+				parent = parent._parent;
+			}
+		}
+		if (!matrix) {
+			matrix = this._globalMatrix = this._matrix.clone();
+			var parent = this._parent;
+			if (parent)
+				matrix.prepend(parent.getGlobalMatrix(true));
+		}
+		return _dontClone ? matrix : matrix.clone();
+	},
+
+	getViewMatrix: function() {
+		return this.getGlobalMatrix().prepend(this.getView()._matrix);
+	},
+
+	getApplyMatrix: function() {
+		return this._applyMatrix;
+	},
+
+	setApplyMatrix: function(apply) {
+		if (this._applyMatrix = this._canApplyMatrix && !!apply)
+			this.transform(null, true);
+	},
+
+	getTransformContent: '#getApplyMatrix',
+	setTransformContent: '#setApplyMatrix',
+}, {
+	getProject: function() {
+		return this._project;
+	},
+
+	_setProject: function(project, installEvents) {
+		if (this._project !== project) {
+			if (this._project)
+				this._installEvents(false);
+			this._project = project;
+			var children = this._children;
+			for (var i = 0, l = children && children.length; i < l; i++)
+				children[i]._setProject(project);
+			installEvents = true;
+		}
+		if (installEvents)
+			this._installEvents(true);
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	_installEvents: function _installEvents(install) {
+		_installEvents.base.call(this, install);
+		var children = this._children;
+		for (var i = 0, l = children && children.length; i < l; i++)
+			children[i]._installEvents(install);
+	},
+
+	getLayer: function() {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent instanceof Layer)
+				return parent;
+		}
+		return null;
+	},
+
+	getParent: function() {
+		return this._parent;
+	},
+
+	setParent: function(item) {
+		return item.addChild(this);
+	},
+
+	_getOwner: '#getParent',
+
+	getChildren: function() {
+		return this._children;
+	},
+
+	setChildren: function(items) {
+		this.removeChildren();
+		this.addChildren(items);
+	},
+
+	getFirstChild: function() {
+		return this._children && this._children[0] || null;
+	},
+
+	getLastChild: function() {
+		return this._children && this._children[this._children.length - 1]
+				|| null;
+	},
+
+	getNextSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index + 1] || null;
+	},
+
+	getPreviousSibling: function() {
+		var owner = this._getOwner();
+		return owner && owner._children[this._index - 1] || null;
+	},
+
+	getIndex: function() {
+		return this._index;
+	},
+
+	equals: function(item) {
+		return item === this || item && this._class === item._class
+				&& this._style.equals(item._style)
+				&& this._matrix.equals(item._matrix)
+				&& this._locked === item._locked
+				&& this._visible === item._visible
+				&& this._blendMode === item._blendMode
+				&& this._opacity === item._opacity
+				&& this._clipMask === item._clipMask
+				&& this._guide === item._guide
+				&& this._equals(item)
+				|| false;
+	},
+
+	_equals: function(item) {
+		return Base.equals(this._children, item._children);
+	},
+
+	clone: function(options) {
+		var copy = new this.constructor(Item.NO_INSERT),
+			children = this._children,
+			insert = Base.pick(options ? options.insert : undefined,
+					options === undefined || options === true),
+			deep = Base.pick(options ? options.deep : undefined, true);
+		if (children)
+			copy.copyAttributes(this);
+		if (!children || deep)
+			copy.copyContent(this);
+		if (!children)
+			copy.copyAttributes(this);
+		if (insert)
+			copy.insertAbove(this);
+		var name = this._name,
+			parent = this._parent;
+		if (name && parent) {
+			var children = parent._children,
+				orig = name,
+				i = 1;
+			while (children[name])
+				name = orig + ' ' + (i++);
+			if (name !== orig)
+				copy.setName(name);
+		}
+		return copy;
+	},
+
+	copyContent: function(source) {
+		var children = source._children;
+		for (var i = 0, l = children && children.length; i < l; i++) {
+			this.addChild(children[i].clone(false), true);
+		}
+	},
+
+	copyAttributes: function(source, excludeMatrix) {
+		this.setStyle(source._style);
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'];
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i];
+			if (source.hasOwnProperty(key))
+				this[key] = source[key];
+		}
+		if (!excludeMatrix)
+			this._matrix.set(source._matrix, true);
+		this.setApplyMatrix(source._applyMatrix);
+		this.setPivot(source._pivot);
+		this.setSelection(source._selection);
+		var data = source._data,
+			name = source._name;
+		this._data = data ? Base.clone(data) : null;
+		if (name)
+			this.setName(name);
+	},
+
+	rasterize: function(resolution, insert) {
+		var bounds = this.getStrokeBounds(),
+			scale = (resolution || this.getView().getResolution()) / 72,
+			topLeft = bounds.getTopLeft().floor(),
+			bottomRight = bounds.getBottomRight().ceil(),
+			size = new Size(bottomRight.subtract(topLeft)),
+			raster = new Raster(Item.NO_INSERT);
+		if (!size.isZero()) {
+			var canvas = CanvasProvider.getCanvas(size.multiply(scale)),
+				ctx = canvas.getContext('2d'),
+				matrix = new Matrix().scale(scale).translate(topLeft.negate());
+			ctx.save();
+			matrix.applyToContext(ctx);
+			this.draw(ctx, new Base({ matrices: [matrix] }));
+			ctx.restore();
+			raster.setCanvas(canvas);
+		}
+		raster.transform(new Matrix().translate(topLeft.add(size.divide(2)))
+				.scale(1 / scale));
+		if (insert === undefined || insert)
+			raster.insertAbove(this);
+		return raster;
+	},
+
+	contains: function() {
+		var matrix = this._matrix;
+		return (
+			matrix.isInvertible() &&
+			!!this._contains(matrix._inverseTransform(Point.read(arguments)))
+		);
+	},
+
+	_contains: function(point) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				if (children[i].contains(point))
+					return true;
+			}
+			return false;
+		}
+		return point.isInside(this.getInternalBounds());
+	},
+
+	isInside: function() {
+		return Rectangle.read(arguments).contains(this.getBounds());
+	},
+
+	_asPathItem: function() {
+		return new Path.Rectangle({
+			rectangle: this.getInternalBounds(),
+			matrix: this._matrix,
+			insert: false,
+		});
+	},
+
+	intersects: function(item, _matrix) {
+		if (!(item instanceof Item))
+			return false;
+		return this._asPathItem().getIntersections(item._asPathItem(), null,
+				_matrix, true).length > 0;
+	}
+},
+new function() {
+	function hitTest() {
+		var args = arguments;
+		return this._hitTest(
+				Point.read(args),
+				HitResult.getOptions(args));
+	}
+
+	function hitTestAll() {
+		var args = arguments,
+			point = Point.read(args),
+			options = HitResult.getOptions(args),
+			all = [];
+		this._hitTest(point, new Base({ all: all }, options));
+		return all;
+	}
+
+	function hitTestChildren(point, options, viewMatrix, _exclude) {
+		var children = this._children;
+		if (children) {
+			for (var i = children.length - 1; i >= 0; i--) {
+				var child = children[i];
+				var res = child !== _exclude && child._hitTest(point, options,
+						viewMatrix);
+				if (res && !options.all)
+					return res;
+			}
+		}
+		return null;
+	}
+
+	Project.inject({
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTest: hitTestChildren
+	});
+
+	return {
+		hitTest: hitTest,
+		hitTestAll: hitTestAll,
+		_hitTestChildren: hitTestChildren,
+	};
+}, {
+
+	_hitTest: function(point, options, parentViewMatrix) {
+		if (this._locked || !this._visible || this._guide && !options.guides
+				|| this.isEmpty()) {
+			return null;
+		}
+
+		var matrix = this._matrix,
+			viewMatrix = parentViewMatrix
+					? parentViewMatrix.appended(matrix)
+					: this.getGlobalMatrix().prepend(this.getView()._matrix),
+			tolerance = Math.max(options.tolerance, 1e-12),
+			tolerancePadding = options._tolerancePadding = new Size(
+					Path._getStrokePadding(tolerance,
+						matrix._shiftless().invert()));
+		point = matrix._inverseTransform(point);
+		if (!point || !this._children &&
+			!this.getBounds({ internal: true, stroke: true, handle: true })
+				.expand(tolerancePadding.multiply(2))._containsPoint(point)) {
+			return null;
+		}
+
+		var checkSelf = !(options.guides && !this._guide
+				|| options.selected && !this.isSelected()
+				|| options.type && options.type !== Base.hyphenate(this._class)
+				|| options.class && !(this instanceof options.class)),
+			match = options.match,
+			that = this,
+			bounds,
+			res;
+
+		function filter(hit) {
+			if (hit && match && !match(hit))
+				hit = null;
+			if (hit && options.all)
+				options.all.push(hit);
+			return hit;
+		}
+
+		function checkPoint(type, part) {
+			var pt = part ? bounds['get' + part]() : that.getPosition();
+			if (point.subtract(pt).divide(tolerancePadding).length <= 1) {
+				return new HitResult(type, that, {
+					name: part ? Base.hyphenate(part) : type,
+					point: pt
+				});
+			}
+		}
+
+		var checkPosition = options.position,
+			checkCenter = options.center,
+			checkBounds = options.bounds;
+		if (checkSelf && this._parent
+				&& (checkPosition || checkCenter || checkBounds)) {
+			if (checkCenter || checkBounds) {
+				bounds = this.getInternalBounds();
+			}
+			res = checkPosition && checkPoint('position') ||
+					checkCenter && checkPoint('center', 'Center');
+			if (!res && checkBounds) {
+				var points = [
+					'TopLeft', 'TopRight', 'BottomLeft', 'BottomRight',
+					'LeftCenter', 'TopCenter', 'RightCenter', 'BottomCenter'
+				];
+				for (var i = 0; i < 8 && !res; i++) {
+					res = checkPoint('bounds', points[i]);
+				}
+			}
+			res = filter(res);
+		}
+
+		if (!res) {
+			res = this._hitTestChildren(point, options, viewMatrix)
+				|| checkSelf
+					&& filter(this._hitTestSelf(point, options, viewMatrix,
+						this.getStrokeScaling() ? null
+							: viewMatrix._shiftless().invert()))
+				|| null;
+		}
+		if (res && res.point) {
+			res.point = matrix.transform(res.point);
+		}
+		return res;
+	},
+
+	_hitTestSelf: function(point, options) {
+		if (options.fill && this.hasFill() && this._contains(point))
+			return new HitResult('fill', this);
+	},
+
+	matches: function(name, compare) {
+		function matchObject(obj1, obj2) {
+			for (var i in obj1) {
+				if (obj1.hasOwnProperty(i)) {
+					var val1 = obj1[i],
+						val2 = obj2[i];
+					if (Base.isPlainObject(val1) && Base.isPlainObject(val2)) {
+						if (!matchObject(val1, val2))
+							return false;
+					} else if (!Base.equals(val1, val2)) {
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+		var type = typeof name;
+		if (type === 'object') {
+			for (var key in name) {
+				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
+					return false;
+			}
+			return true;
+		} else if (type === 'function') {
+			return name(this);
+		} else if (name === 'match') {
+			return compare(this);
+		} else {
+			var value = /^(empty|editable)$/.test(name)
+					? this['is' + Base.capitalize(name)]()
+					: name === 'type'
+						? Base.hyphenate(this._class)
+						: this[name];
+			if (name === 'class') {
+				if (typeof compare === 'function')
+					return this instanceof compare;
+				value = this._class;
+			}
+			if (typeof compare === 'function') {
+				return !!compare(value);
+			} else if (compare) {
+				if (compare.test) {
+					return compare.test(value);
+				} else if (Base.isPlainObject(compare)) {
+					return matchObject(compare, value);
+				}
+			}
+			return Base.equals(value, compare);
+		}
+	},
+
+	getItems: function(options) {
+		return Item._getItems(this, options, this._matrix);
+	},
+
+	getItem: function(options) {
+		return Item._getItems(this, options, this._matrix, null, true)[0]
+				|| null;
+	},
+
+	statics: {
+		_getItems: function _getItems(item, options, matrix, param, firstOnly) {
+			if (!param) {
+				var obj = typeof options === 'object' && options,
+					overlapping = obj && obj.overlapping,
+					inside = obj && obj.inside,
+					bounds = overlapping || inside,
+					rect = bounds && Rectangle.read([bounds]);
+				param = {
+					items: [],
+					recursive: obj && obj.recursive !== false,
+					inside: !!inside,
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
+						rectangle: rect,
+						insert: false
+					})
+				};
+				if (obj) {
+					options = Base.filter({}, options, {
+						recursive: true, inside: true, overlapping: true
+					});
+				}
+			}
+			var children = item._children,
+				items = param.items,
+				rect = param.rect;
+			matrix = rect && (matrix || new Matrix());
+			for (var i = 0, l = children && children.length; i < l; i++) {
+				var child = children[i],
+					childMatrix = matrix && matrix.appended(child._matrix),
+					add = true;
+				if (rect) {
+					var bounds = child.getBounds(childMatrix);
+					if (!rect.intersects(bounds))
+						continue;
+					if (!(rect.contains(bounds)
+							|| param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
+						add = false;
+				}
+				if (add && child.matches(options)) {
+					items.push(child);
+					if (firstOnly)
+						break;
+				}
+				if (param.recursive !== false) {
+					_getItems(child, options, childMatrix, param, firstOnly);
+				}
+				if (firstOnly && items.length > 0)
+					break;
+			}
+			return items;
+		}
+	}
+}, {
+
+	importJSON: function(json) {
+		var res = Base.importJSON(json, this);
+		return res !== this ? this.addChild(res) : res;
+	},
+
+	addChild: function(item) {
+		return this.insertChild(undefined, item);
+	},
+
+	insertChild: function(index, item) {
+		var res = item ? this.insertChildren(index, [item]) : null;
+		return res && res[0];
+	},
+
+	addChildren: function(items) {
+		return this.insertChildren(this._children.length, items);
+	},
+
+	insertChildren: function(index, items) {
+		var children = this._children;
+		if (children && items && items.length > 0) {
+			items = Base.slice(items);
+			var inserted = {};
+			for (var i = items.length - 1; i >= 0; i--) {
+				var item = items[i],
+					id = item && item._id;
+				if (!item || inserted[id]) {
+					items.splice(i, 1);
+				} else {
+					item._remove(false, true);
+					inserted[id] = true;
+				}
+			}
+			Base.splice(children, items, index, 0);
+			var project = this._project,
+				notifySelf = project._changes;
+			for (var i = 0, l = items.length; i < l; i++) {
+				var item = items[i],
+					name = item._name;
+				item._parent = this;
+				item._setProject(project, true);
+				if (name)
+					item.setName(name);
+				if (notifySelf)
+					item._changed(5);
+			}
+			this._changed(11);
+		} else {
+			items = null;
+		}
+		return items;
+	},
+
+	_insertItem: '#insertChild',
+
+	_insertAt: function(item, offset) {
+		var owner = item && item._getOwner(),
+			res = item !== this && owner ? this : null;
+		if (res) {
+			res._remove(false, true);
+			owner._insertItem(item._index + offset, res);
+		}
+		return res;
+	},
+
+	insertAbove: function(item) {
+		return this._insertAt(item, 1);
+	},
+
+	insertBelow: function(item) {
+		return this._insertAt(item, 0);
+	},
+
+	sendToBack: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(0, this) : null;
+	},
+
+	bringToFront: function() {
+		var owner = this._getOwner();
+		return owner ? owner._insertItem(undefined, this) : null;
+	},
+
+	appendTop: '#addChild',
+
+	appendBottom: function(item) {
+		return this.insertChild(0, item);
+	},
+
+	moveAbove: '#insertAbove',
+
+	moveBelow: '#insertBelow',
+
+	addTo: function(owner) {
+		return owner._insertItem(undefined, this);
+	},
+
+	copyTo: function(owner) {
+		return this.clone(false).addTo(owner);
+	},
+
+	reduce: function(options) {
+		var children = this._children;
+		if (children && children.length === 1) {
+			var child = children[0].reduce(options);
+			if (this._parent) {
+				child.insertAbove(this);
+				this.remove();
+			} else {
+				child.remove();
+			}
+			return child;
+		}
+		return this;
+	},
+
+	_removeNamed: function() {
+		var owner = this._getOwner();
+		if (owner) {
+			var children = owner._children,
+				namedChildren = owner._namedChildren,
+				name = this._name,
+				namedArray = namedChildren[name],
+				index = namedArray ? namedArray.indexOf(this) : -1;
+			if (index !== -1) {
+				if (children[name] == this)
+					delete children[name];
+				namedArray.splice(index, 1);
+				if (namedArray.length) {
+					children[name] = namedArray[0];
+				} else {
+					delete namedChildren[name];
+				}
+			}
+		}
+	},
+
+	_remove: function(notifySelf, notifyParent) {
+		var owner = this._getOwner(),
+			project = this._project,
+			index = this._index;
+		if (this._style)
+			this._style._dispose();
+		if (owner) {
+			if (this._name)
+				this._removeNamed();
+			if (index != null) {
+				if (project._activeLayer === this)
+					project._activeLayer = this.getNextSibling()
+							|| this.getPreviousSibling();
+				Base.splice(owner._children, null, index, 1);
+			}
+			this._installEvents(false);
+			if (notifySelf && project._changes)
+				this._changed(5);
+			if (notifyParent)
+				owner._changed(11, this);
+			this._parent = null;
+			return true;
+		}
+		return false;
+	},
+
+	remove: function() {
+		return this._remove(true, true);
+	},
+
+	replaceWith: function(item) {
+		var ok = item && item.insertBelow(this);
+		if (ok)
+			this.remove();
+		return ok;
+	},
+
+	removeChildren: function(start, end) {
+		if (!this._children)
+			return null;
+		start = start || 0;
+		end = Base.pick(end, this._children.length);
+		var removed = Base.splice(this._children, null, start, end - start);
+		for (var i = removed.length - 1; i >= 0; i--) {
+			removed[i]._remove(true, false);
+		}
+		if (removed.length > 0)
+			this._changed(11);
+		return removed;
+	},
+
+	clear: '#removeChildren',
+
+	reverseChildren: function() {
+		if (this._children) {
+			this._children.reverse();
+			for (var i = 0, l = this._children.length; i < l; i++)
+				this._children[i]._index = i;
+			this._changed(11);
+		}
+	},
+
+	isEmpty: function(recursively) {
+		var children = this._children;
+		var numChildren = children ? children.length : 0;
+		if (recursively) {
+			for (var i = 0; i < numChildren; i++) {
+				if (!children[i].isEmpty(recursively)) {
+					return false;
+				}
+			}
+			return true;
+		}
+		return !numChildren;
+	},
+
+	isEditable: function() {
+		var item = this;
+		while (item) {
+			if (!item._visible || item._locked)
+				return false;
+			item = item._parent;
+		}
+		return true;
+	},
+
+	hasFill: function() {
+		return this.getStyle().hasFill();
+	},
+
+	hasStroke: function() {
+		return this.getStyle().hasStroke();
+	},
+
+	hasShadow: function() {
+		return this.getStyle().hasShadow();
+	},
+
+	_getOrder: function(item) {
+		function getList(item) {
+			var list = [];
+			do {
+				list.unshift(item);
+			} while (item = item._parent);
+			return list;
+		}
+		var list1 = getList(this),
+			list2 = getList(item);
+		for (var i = 0, l = Math.min(list1.length, list2.length); i < l; i++) {
+			if (list1[i] != list2[i]) {
+				return list1[i]._index < list2[i]._index ? 1 : -1;
+			}
+		}
+		return 0;
+	},
+
+	hasChildren: function() {
+		return this._children && this._children.length > 0;
+	},
+
+	isInserted: function() {
+		return this._parent ? this._parent.isInserted() : false;
+	},
+
+	isAbove: function(item) {
+		return this._getOrder(item) === -1;
+	},
+
+	isBelow: function(item) {
+		return this._getOrder(item) === 1;
+	},
+
+	isParent: function(item) {
+		return this._parent === item;
+	},
+
+	isChild: function(item) {
+		return item && item._parent === this;
+	},
+
+	isDescendant: function(item) {
+		var parent = this;
+		while (parent = parent._parent) {
+			if (parent === item)
+				return true;
+		}
+		return false;
+	},
+
+	isAncestor: function(item) {
+		return item ? item.isDescendant(this) : false;
+	},
+
+	isSibling: function(item) {
+		return this._parent === item._parent;
+	},
+
+	isGroupedWith: function(item) {
+		var parent = this._parent;
+		while (parent) {
+			if (parent._parent
+				&& /^(Group|Layer|CompoundPath)$/.test(parent._class)
+				&& item.isDescendant(parent))
+					return true;
+			parent = parent._parent;
+		}
+		return false;
+	},
+
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getPosition(true)));
+	};
+}, {
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	transform: function(matrix, _applyRecursively, _setApplyMatrix) {
+		var _matrix = this._matrix,
+			transformMatrix = matrix && !matrix.isIdentity(),
+			applyMatrix = (
+				_setApplyMatrix && this._canApplyMatrix ||
+				this._applyMatrix && (
+					transformMatrix || !_matrix.isIdentity() ||
+					_applyRecursively && this._children
+				)
+			);
+		if (!transformMatrix && !applyMatrix)
+			return this;
+		if (transformMatrix) {
+			if (!matrix.isInvertible() && _matrix.isInvertible())
+				_matrix._backup = _matrix.getValues();
+			_matrix.prepend(matrix, true);
+			var style = this._style,
+				fillColor = style.getFillColor(true),
+				strokeColor = style.getStrokeColor(true);
+			if (fillColor)
+				fillColor.transform(matrix);
+			if (strokeColor)
+				strokeColor.transform(matrix);
+		}
+
+		if (applyMatrix && (applyMatrix = this._transformContent(
+				_matrix, _applyRecursively, _setApplyMatrix))) {
+			var pivot = this._pivot;
+			if (pivot)
+				_matrix._transformPoint(pivot, pivot, true);
+			_matrix.reset(true);
+			if (_setApplyMatrix && this._canApplyMatrix)
+				this._applyMatrix = true;
+		}
+		var bounds = this._bounds,
+			position = this._position;
+		if (transformMatrix || applyMatrix) {
+			this._changed(25);
+		}
+		var decomp = transformMatrix && bounds && matrix.decompose();
+		if (decomp && decomp.skewing.isZero() && decomp.rotation % 90 === 0) {
+			for (var key in bounds) {
+				var cache = bounds[key];
+				if (cache.nonscaling) {
+					delete bounds[key];
+				} else if (applyMatrix || !cache.internal) {
+					var rect = cache.rect;
+					matrix._transformBounds(rect, rect);
+				}
+			}
+			this._bounds = bounds;
+			var cached = bounds[this._getBoundsCacheKey(
+				this._boundsOptions || {})];
+			if (cached) {
+				this._position = this._getPositionFromBounds(cached.rect);
+			}
+		} else if (transformMatrix && position && this._pivot) {
+			this._position = matrix._transformPoint(position, position);
+		}
+		return this;
+	},
+
+	_transformContent: function(matrix, applyRecursively, setApplyMatrix) {
+		var children = this._children;
+		if (children) {
+			for (var i = 0, l = children.length; i < l; i++) {
+				children[i].transform(matrix, applyRecursively, setApplyMatrix);
+			}
+			return true;
+		}
+	},
+
+	globalToLocal: function() {
+		return this.getGlobalMatrix(true)._inverseTransform(
+				Point.read(arguments));
+	},
+
+	localToGlobal: function() {
+		return this.getGlobalMatrix(true)._transformPoint(
+				Point.read(arguments));
+	},
+
+	parentToLocal: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	localToParent: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	fitBounds: function(rectangle, fill) {
+		rectangle = Rectangle.read(arguments);
+		var bounds = this.getBounds(),
+			itemRatio = bounds.height / bounds.width,
+			rectRatio = rectangle.height / rectangle.width,
+			scale = (fill ? itemRatio > rectRatio : itemRatio < rectRatio)
+					? rectangle.width / bounds.width
+					: rectangle.height / bounds.height,
+			newBounds = new Rectangle(new Point(),
+					new Size(bounds.width * scale, bounds.height * scale));
+		newBounds.setCenter(rectangle.getCenter());
+		this.setBounds(newBounds);
+	}
+}), {
+
+	_setStyles: function(ctx, param, viewMatrix) {
+		var style = this._style,
+			matrix = this._matrix;
+		if (style.hasFill()) {
+			ctx.fillStyle = style.getFillColor().toCanvasStyle(ctx, matrix);
+		}
+		if (style.hasStroke()) {
+			ctx.strokeStyle = style.getStrokeColor().toCanvasStyle(ctx, matrix);
+			ctx.lineWidth = style.getStrokeWidth();
+			var strokeJoin = style.getStrokeJoin(),
+				strokeCap = style.getStrokeCap(),
+				miterLimit = style.getMiterLimit();
+			if (strokeJoin)
+				ctx.lineJoin = strokeJoin;
+			if (strokeCap)
+				ctx.lineCap = strokeCap;
+			if (miterLimit)
+				ctx.miterLimit = miterLimit;
+			if (paper.support.nativeDash) {
+				var dashArray = style.getDashArray(),
+					dashOffset = style.getDashOffset();
+				if (dashArray && dashArray.length) {
+					if ('setLineDash' in ctx) {
+						ctx.setLineDash(dashArray);
+						ctx.lineDashOffset = dashOffset;
+					} else {
+						ctx.mozDash = dashArray;
+						ctx.mozDashOffset = dashOffset;
+					}
+				}
+			}
+		}
+		if (style.hasShadow()) {
+			var pixelRatio = param.pixelRatio || 1,
+				mx = viewMatrix._shiftless().prepend(
+					new Matrix().scale(pixelRatio, pixelRatio)),
+				blur = mx.transform(new Point(style.getShadowBlur(), 0)),
+				offset = mx.transform(this.getShadowOffset());
+			ctx.shadowColor = style.getShadowColor().toCanvasStyle(ctx);
+			ctx.shadowBlur = blur.getLength();
+			ctx.shadowOffsetX = offset.x;
+			ctx.shadowOffsetY = offset.y;
+		}
+	},
+
+	draw: function(ctx, param, parentStrokeMatrix) {
+		var updateVersion = this._updateVersion = this._project._updateVersion;
+		if (!this._visible || this._opacity === 0)
+			return;
+		var matrices = param.matrices,
+			viewMatrix = param.viewMatrix,
+			matrix = this._matrix,
+			globalMatrix = matrices[matrices.length - 1].appended(matrix);
+		if (!globalMatrix.isInvertible())
+			return;
+
+		viewMatrix = viewMatrix ? viewMatrix.appended(globalMatrix)
+				: globalMatrix;
+
+		matrices.push(globalMatrix);
+		if (param.updateMatrix) {
+			this._globalMatrix = globalMatrix;
+		}
+
+		var blendMode = this._blendMode,
+			opacity = Numerical.clamp(this._opacity, 0, 1),
+			normalBlend = blendMode === 'normal',
+			nativeBlend = BlendMode.nativeModes[blendMode],
+			direct = normalBlend && opacity === 1
+					|| param.dontStart
+					|| param.clip
+					|| (nativeBlend || normalBlend && opacity < 1)
+						&& this._canComposite(),
+			pixelRatio = param.pixelRatio || 1,
+			mainCtx, itemOffset, prevOffset;
+		if (!direct) {
+			var bounds = this.getStrokeBounds(viewMatrix);
+			if (!bounds.width || !bounds.height) {
+				matrices.pop();
+				return;
+			}
+			prevOffset = param.offset;
+			itemOffset = param.offset = bounds.getTopLeft().floor();
+			mainCtx = ctx;
+			ctx = CanvasProvider.getContext(bounds.getSize().ceil().add(1)
+					.multiply(pixelRatio));
+			if (pixelRatio !== 1)
+				ctx.scale(pixelRatio, pixelRatio);
+		}
+		ctx.save();
+		var strokeMatrix = parentStrokeMatrix
+				? parentStrokeMatrix.appended(matrix)
+				: this._canScaleStroke && !this.getStrokeScaling(true)
+					&& viewMatrix,
+			clip = !direct && param.clipItem,
+			transform = !strokeMatrix || clip;
+		if (direct) {
+			ctx.globalAlpha = opacity;
+			if (nativeBlend)
+				ctx.globalCompositeOperation = blendMode;
+		} else if (transform) {
+			ctx.translate(-itemOffset.x, -itemOffset.y);
+		}
+		if (transform) {
+			(direct ? matrix : viewMatrix).applyToContext(ctx);
+		}
+		if (clip) {
+			param.clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		if (strokeMatrix) {
+			ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+			var offset = param.offset;
+			if (offset)
+				ctx.translate(-offset.x, -offset.y);
+		}
+		this._draw(ctx, param, viewMatrix, strokeMatrix);
+		ctx.restore();
+		matrices.pop();
+		if (param.clip && !param.dontFinish) {
+			ctx.clip(this.getFillRule());
+		}
+		if (!direct) {
+			BlendMode.process(blendMode, ctx, mainCtx, opacity,
+					itemOffset.subtract(prevOffset).multiply(pixelRatio));
+			CanvasProvider.release(ctx);
+			param.offset = prevOffset;
+		}
+	},
+
+	_isUpdated: function(updateVersion) {
+		var parent = this._parent;
+		if (parent instanceof CompoundPath)
+			return parent._isUpdated(updateVersion);
+		var updated = this._updateVersion === updateVersion;
+		if (!updated && parent && parent._visible
+				&& parent._isUpdated(updateVersion)) {
+			this._updateVersion = updateVersion;
+			updated = true;
+		}
+		return updated;
+	},
+
+	_drawSelection: function(ctx, matrix, size, selectionItems, updateVersion) {
+		var selection = this._selection,
+			itemSelected = selection & 1,
+			boundsSelected = selection & 2
+					|| itemSelected && this._selectBounds,
+			positionSelected = selection & 4;
+		if (!this._drawSelected)
+			itemSelected = false;
+		if ((itemSelected || boundsSelected || positionSelected)
+				&& this._isUpdated(updateVersion)) {
+			var layer,
+				color = this.getSelectedColor(true) || (layer = this.getLayer())
+					&& layer.getSelectedColor(true),
+				mx = matrix.appended(this.getGlobalMatrix(true)),
+				half = size / 2;
+			ctx.strokeStyle = ctx.fillStyle = color
+					? color.toCanvasStyle(ctx) : '#009dec';
+			if (itemSelected)
+				this._drawSelected(ctx, mx, selectionItems);
+			if (positionSelected) {
+				var pos = this.getPosition(true),
+					parent = this._parent,
+					point = parent ? parent.localToGlobal(pos) : pos,
+					x = point.x,
+					y = point.y;
+				ctx.beginPath();
+				ctx.arc(x, y, half, 0, Math.PI * 2, true);
+				ctx.stroke();
+				var deltas = [[0, -1], [1, 0], [0, 1], [-1, 0]],
+					start = half,
+					end = size + 1;
+				for (var i = 0; i < 4; i++) {
+					var delta = deltas[i],
+						dx = delta[0],
+						dy = delta[1];
+					ctx.moveTo(x + dx * start, y + dy * start);
+					ctx.lineTo(x + dx * end, y + dy * end);
+					ctx.stroke();
+				}
+			}
+			if (boundsSelected) {
+				var coords = mx._transformCorners(this.getInternalBounds());
+				ctx.beginPath();
+				for (var i = 0; i < 8; i++) {
+					ctx[!i ? 'moveTo' : 'lineTo'](coords[i], coords[++i]);
+				}
+				ctx.closePath();
+				ctx.stroke();
+				for (var i = 0; i < 8; i++) {
+					ctx.fillRect(coords[i] - half, coords[++i] - half,
+							size, size);
+				}
+			}
+		}
+	},
+
+	_canComposite: function() {
+		return false;
+	}
+}, Base.each(['down', 'drag', 'up', 'move'], function(key) {
+	this['removeOn' + Base.capitalize(key)] = function() {
+		var hash = {};
+		hash[key] = true;
+		return this.removeOn(hash);
+	};
+}, {
+
+	removeOn: function(obj) {
+		for (var name in obj) {
+			if (obj[name]) {
+				var key = 'mouse' + name,
+					project = this._project,
+					sets = project._removeSets = project._removeSets || {};
+				sets[key] = sets[key] || {};
+				sets[key][this._id] = this;
+			}
+		}
+		return this;
+	}
+}), {
+	tween: function(from, to, options) {
+		if (!options) {
+			options = to;
+			to = from;
+			from = null;
+			if (!options) {
+				options = to;
+				to = null;
+			}
+		}
+		var easing = options && options.easing,
+			start = options && options.start,
+			duration = options != null && (
+				typeof options === 'number' ? options : options.duration
+			),
+			tween = new Tween(this, from, to, duration, easing, start);
+		function onFrame(event) {
+			tween._handleFrame(event.time * 1000);
+			if (!tween.running) {
+				this.off('frame', onFrame);
+			}
+		}
+		if (duration) {
+			this.on('frame', onFrame);
+		}
+		return tween;
+	},
+
+	tweenTo: function(to, options) {
+		return this.tween(null, to, options);
+	},
+
+	tweenFrom: function(from, options) {
+		return this.tween(from, null, options);
+	}
+});
+
+var Group = Item.extend({
+	_class: 'Group',
+	_selectBounds: false,
+	_selectChildren: true,
+	_serializeFields: {
+		children: []
+	},
+
+	initialize: function Group(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg))
+			this.addChildren(Array.isArray(arg) ? arg : arguments);
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 2050) {
+			this._clipItem = undefined;
+		}
+	},
+
+	_getClipItem: function() {
+		var clipItem = this._clipItem;
+		if (clipItem === undefined) {
+			clipItem = null;
+			var children = this._children;
+			for (var i = 0, l = children.length; i < l; i++) {
+				if (children[i]._clipMask) {
+					clipItem = children[i];
+					break;
+				}
+			}
+			this._clipItem = clipItem;
+		}
+		return clipItem;
+	},
+
+	isClipped: function() {
+		return !!this._getClipItem();
+	},
+
+	setClipped: function(clipped) {
+		var child = this.getFirstChild();
+		if (child)
+			child.setClipMask(clipped);
+	},
+
+	_getBounds: function _getBounds(matrix, options) {
+		var clipItem = this._getClipItem();
+		return clipItem
+			? clipItem._getCachedBounds(clipItem._matrix.prepended(matrix),
+				Base.set({}, options, { stroke: false }))
+			: _getBounds.base.call(this, matrix, options);
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		var clipItem = this._getClipItem();
+		return (!clipItem || clipItem.contains(point))
+				&& _hitTestChildren.base.call(this, point, options, viewMatrix,
+					clipItem);
+	},
+
+	_draw: function(ctx, param) {
+		var clip = param.clip,
+			clipItem = !clip && this._getClipItem();
+		param = param.extend({ clipItem: clipItem, clip: false });
+		if (clip) {
+			ctx.beginPath();
+			param.dontStart = param.dontFinish = true;
+		} else if (clipItem) {
+			clipItem.draw(ctx, param.extend({ clip: true }));
+		}
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var item = children[i];
+			if (item !== clipItem)
+				item.draw(ctx, param);
+		}
+	}
+});
+
+var Layer = Group.extend({
+	_class: 'Layer',
+
+	initialize: function Layer() {
+		Group.apply(this, arguments);
+	},
+
+	_getOwner: function() {
+		return this._parent || this._index != null && this._project;
+	},
+
+	isInserted: function isInserted() {
+		return this._parent ? isInserted.base.call(this) : this._index != null;
+	},
+
+	activate: function() {
+		this._project._activeLayer = this;
+	},
+
+	_hitTestSelf: function() {
+	}
+});
+
+var Shape = Item.extend({
+	_class: 'Shape',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_canScaleStroke: true,
+	_serializeFields: {
+		type: null,
+		size: null,
+		radius: null
+	},
+
+	initialize: function Shape(props, point) {
+		this._initialize(props, point);
+	},
+
+	_equals: function(item) {
+		return this._type === item._type
+			&& this._size.equals(item._size)
+			&& Base.equals(this._radius, item._radius);
+	},
+
+	copyContent: function(source) {
+		this.setType(source._type);
+		this.setSize(source._size);
+		this.setRadius(source._radius);
+	},
+
+	getType: function() {
+		return this._type;
+	},
+
+	setType: function(type) {
+		this._type = type;
+	},
+
+	getShape: '#getType',
+	setShape: '#setType',
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size.width, size.height, this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!this._size) {
+			this._size = size.clone();
+		} else if (!this._size.equals(size)) {
+			var type = this._type,
+				width = size.width,
+				height = size.height;
+			if (type === 'rectangle') {
+				this._radius.set(Size.min(this._radius, size.divide(2).abs()));
+			} else if (type === 'circle') {
+				width = height = (width + height) / 2;
+				this._radius = width / 2;
+			} else if (type === 'ellipse') {
+				this._radius._set(width / 2, height / 2);
+			}
+			this._size._set(width, height);
+			this._changed(9);
+		}
+	},
+
+	getRadius: function() {
+		var rad = this._radius;
+		return this._type === 'circle'
+				? rad
+				: new LinkedSize(rad.width, rad.height, this, 'setRadius');
+	},
+
+	setRadius: function(radius) {
+		var type = this._type;
+		if (type === 'circle') {
+			if (radius === this._radius)
+				return;
+			var size = radius * 2;
+			this._radius = radius;
+			this._size._set(size, size);
+		} else {
+			radius = Size.read(arguments);
+			if (!this._radius) {
+				this._radius = radius.clone();
+			} else {
+				if (this._radius.equals(radius))
+					return;
+				this._radius.set(radius);
+				if (type === 'rectangle') {
+					var size = Size.max(this._size, radius.multiply(2));
+					this._size.set(size);
+				} else if (type === 'ellipse') {
+					this._size._set(radius.width * 2, radius.height * 2);
+				}
+			}
+		}
+		this._changed(9);
+	},
+
+	isEmpty: function() {
+		return false;
+	},
+
+	toPath: function(insert) {
+		var path = new Path[Base.capitalize(this._type)]({
+			center: new Point(),
+			size: this._size,
+			radius: this._radius,
+			insert: false
+		});
+		path.copyAttributes(this);
+		if (paper.settings.applyMatrix)
+			path.setApplyMatrix(true);
+		if (insert === undefined || insert)
+			path.insertAbove(this);
+		return path;
+	},
+
+	toShape: '#clone',
+
+	_asPathItem: function() {
+		return this.toPath(false);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			dontPaint = param.dontFinish || param.clip,
+			untransformed = !strokeMatrix;
+		if (hasFill || hasStroke || dontPaint) {
+			var type = this._type,
+				radius = this._radius,
+				isCircle = type === 'circle';
+			if (!param.dontStart)
+				ctx.beginPath();
+			if (untransformed && isCircle) {
+				ctx.arc(0, 0, radius, 0, Math.PI * 2, true);
+			} else {
+				var rx = isCircle ? radius : radius.width,
+					ry = isCircle ? radius : radius.height,
+					size = this._size,
+					width = size.width,
+					height = size.height;
+				if (untransformed && type === 'rectangle' && rx === 0 && ry === 0) {
+					ctx.rect(-width / 2, -height / 2, width, height);
+				} else {
+					var x = width / 2,
+						y = height / 2,
+						kappa = 1 - 0.5522847498307936,
+						cx = rx * kappa,
+						cy = ry * kappa,
+						c = [
+							-x, -y + ry,
+							-x, -y + cy,
+							-x + cx, -y,
+							-x + rx, -y,
+							x - rx, -y,
+							x - cx, -y,
+							x, -y + cy,
+							x, -y + ry,
+							x, y - ry,
+							x, y - cy,
+							x - cx, y,
+							x - rx, y,
+							-x + rx, y,
+							-x + cx, y,
+							-x, y - cy,
+							-x, y - ry
+						];
+					if (strokeMatrix)
+						strokeMatrix.transform(c, c, 32);
+					ctx.moveTo(c[0], c[1]);
+					ctx.bezierCurveTo(c[2], c[3], c[4], c[5], c[6], c[7]);
+					if (x !== rx)
+						ctx.lineTo(c[8], c[9]);
+					ctx.bezierCurveTo(c[10], c[11], c[12], c[13], c[14], c[15]);
+					if (y !== ry)
+						ctx.lineTo(c[16], c[17]);
+					ctx.bezierCurveTo(c[18], c[19], c[20], c[21], c[22], c[23]);
+					if (x !== rx)
+						ctx.lineTo(c[24], c[25]);
+					ctx.bezierCurveTo(c[26], c[27], c[28], c[29], c[30], c[31]);
+				}
+			}
+			ctx.closePath();
+		}
+		if (!dontPaint && (hasFill || hasStroke)) {
+			this._setStyles(ctx, param, viewMatrix);
+			if (hasFill) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.stroke();
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0),
+			style = this._style,
+			strokeWidth = options.stroke && style.hasStroke()
+					&& style.getStrokeWidth();
+		if (matrix)
+			rect = matrix._transformBounds(rect);
+		return strokeWidth
+				? rect.expand(Path._getStrokePadding(strokeWidth,
+					this._getStrokeMatrix(matrix, options)))
+				: rect;
+	}
+},
+new function() {
+	function getCornerCenter(that, point, expand) {
+		var radius = that._radius;
+		if (!radius.isZero()) {
+			var halfSize = that._size.divide(2);
+			for (var q = 1; q <= 4; q++) {
+				var dir = new Point(q > 1 && q < 4 ? -1 : 1, q > 2 ? -1 : 1),
+					corner = dir.multiply(halfSize),
+					center = corner.subtract(dir.multiply(radius)),
+					rect = new Rectangle(
+							expand ? corner.add(dir.multiply(expand)) : corner,
+							center);
+				if (rect.contains(point))
+					return { point: center, quadrant: q };
+			}
+		}
+	}
+
+	function isOnEllipseStroke(point, radius, padding, quadrant) {
+		var vector = point.divide(radius);
+		return (!quadrant || vector.isInQuadrant(quadrant)) &&
+				vector.subtract(vector.normalize()).multiply(radius)
+					.divide(padding).length <= 1;
+	}
+
+	return {
+		_contains: function _contains(point) {
+			if (this._type === 'rectangle') {
+				var center = getCornerCenter(this, point);
+				return center
+						? point.subtract(center.point).divide(this._radius)
+							.getLength() <= 1
+						: _contains.base.call(this, point);
+			} else {
+				return point.divide(this.size).getLength() <= 0.5;
+			}
+		},
+
+		_hitTestSelf: function _hitTestSelf(point, options, viewMatrix,
+				strokeMatrix) {
+			var hit = false,
+				style = this._style,
+				hitStroke = options.stroke && style.hasStroke(),
+				hitFill = options.fill && style.hasFill();
+			if (hitStroke || hitFill) {
+				var type = this._type,
+					radius = this._radius,
+					strokeRadius = hitStroke ? style.getStrokeWidth() / 2 : 0,
+					strokePadding = options._tolerancePadding.add(
+						Path._getStrokePadding(strokeRadius,
+							!style.getStrokeScaling() && strokeMatrix));
+				if (type === 'rectangle') {
+					var padding = strokePadding.multiply(2),
+						center = getCornerCenter(this, point, padding);
+					if (center) {
+						hit = isOnEllipseStroke(point.subtract(center.point),
+								radius, strokePadding, center.quadrant);
+					} else {
+						var rect = new Rectangle(this._size).setCenter(0, 0),
+							outer = rect.expand(padding),
+							inner = rect.expand(padding.negate());
+						hit = outer._containsPoint(point)
+								&& !inner._containsPoint(point);
+					}
+				} else {
+					hit = isOnEllipseStroke(point, radius, strokePadding);
+				}
+			}
+			return hit ? new HitResult(hitStroke ? 'stroke' : 'fill', this)
+					: _hitTestSelf.base.apply(this, arguments);
+		}
+	};
+}, {
+
+statics: new function() {
+	function createShape(type, point, size, radius, args) {
+		var item = Base.create(Shape.prototype);
+		item._type = type;
+		item._size = size;
+		item._radius = radius;
+		item._initialize(Base.getNamed(args), point);
+		return item;
+	}
+
+	return {
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createShape('circle', center, new Size(radius * 2), radius,
+					args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.min(Size.readNamed(args, 'radius'),
+						rect.getSize(true).divide(2));
+			return createShape('rectangle', rect.getCenter(true),
+					rect.getSize(true), radius, args);
+		},
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args),
+				radius = ellipse.radius;
+			return createShape('ellipse', ellipse.center, radius.multiply(2),
+					radius, args);
+		},
+
+		_readEllipse: function(args) {
+			var center,
+				radius;
+			if (Base.hasNamed(args, 'radius')) {
+				center = Point.readNamed(args, 'center');
+				radius = Size.readNamed(args, 'radius');
+			} else {
+				var rect = Rectangle.readNamed(args, 'rectangle');
+				center = rect.getCenter(true);
+				radius = rect.getSize(true).divide(2);
+			}
+			return { center: center, radius: radius };
+		}
+	};
+}});
+
+var Raster = Item.extend({
+	_class: 'Raster',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: false, handle: false },
+	_serializeFields: {
+		crossOrigin: null,
+		source: null
+	},
+	_prioritize: ['crossOrigin'],
+	_smoothing: true,
+	beans: true,
+
+	initialize: function Raster(source, position) {
+		if (!this._initialize(source,
+				position !== undefined && Point.read(arguments))) {
+			var image,
+				type = typeof source,
+				object = type === 'string'
+					? document.getElementById(source)
+					: type  === 'object'
+						? source
+						: null;
+			if (object && object !== Item.NO_INSERT) {
+				if (object.getContext || object.naturalHeight != null) {
+					image = object;
+				} else if (object) {
+					var size = Size.read(arguments);
+					if (!size.isZero()) {
+						image = CanvasProvider.getCanvas(size);
+					}
+				}
+			}
+			if (image) {
+				this.setImage(image);
+			} else {
+				this.setSource(source);
+			}
+		}
+		if (!this._size) {
+			this._size = new Size();
+			this._loaded = false;
+		}
+	},
+
+	_equals: function(item) {
+		return this.getSource() === item.getSource();
+	},
+
+	copyContent: function(source) {
+		var image = source._image,
+			canvas = source._canvas;
+		if (image) {
+			this._setImage(image);
+		} else if (canvas) {
+			var copyCanvas = CanvasProvider.getCanvas(source._size);
+			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
+			this._setImage(copyCanvas);
+		}
+		this._crossOrigin = source._crossOrigin;
+	},
+
+	getSize: function() {
+		var size = this._size;
+		return new LinkedSize(size ? size.width : 0, size ? size.height : 0,
+				this, 'setSize');
+	},
+
+	setSize: function() {
+		var size = Size.read(arguments);
+		if (!size.equals(this._size)) {
+			if (size.width > 0 && size.height > 0) {
+				var element = this.getElement();
+				this._setImage(CanvasProvider.getCanvas(size));
+				if (element)
+					this.getContext(true).drawImage(element, 0, 0,
+							size.width, size.height);
+			} else {
+				if (this._canvas)
+					CanvasProvider.release(this._canvas);
+				this._size = size.clone();
+			}
+		}
+	},
+
+	getWidth: function() {
+		return this._size ? this._size.width : 0;
+	},
+
+	setWidth: function(width) {
+		this.setSize(width, this.getHeight());
+	},
+
+	getHeight: function() {
+		return this._size ? this._size.height : 0;
+	},
+
+	setHeight: function(height) {
+		this.setSize(this.getWidth(), height);
+	},
+
+	getLoaded: function() {
+		return this._loaded;
+	},
+
+	isEmpty: function() {
+		var size = this._size;
+		return !size || size.width === 0 && size.height === 0;
+	},
+
+	getResolution: function() {
+		var matrix = this._matrix,
+			orig = new Point(0, 0).transform(matrix),
+			u = new Point(1, 0).transform(matrix).subtract(orig),
+			v = new Point(0, 1).transform(matrix).subtract(orig);
+		return new Size(
+			72 / u.getLength(),
+			72 / v.getLength()
+		);
+	},
+
+	getPpi: '#getResolution',
+
+	getImage: function() {
+		return this._image;
+	},
+
+	setImage: function(image) {
+		var that = this;
+
+		function emit(event) {
+			var view = that.getView(),
+				type = event && event.type || 'load';
+			if (view && that.responds(type)) {
+				paper = view._scope;
+				that.emit(type, new Event(event));
+			}
+		}
+
+		this._setImage(image);
+		if (this._loaded) {
+			setTimeout(emit, 0);
+		} else if (image) {
+			DomEvent.add(image, {
+				load: function(event) {
+					that._setImage(image);
+					emit(event);
+				},
+				error: emit
+			});
+		}
+	},
+
+	_setImage: function(image) {
+		if (this._canvas)
+			CanvasProvider.release(this._canvas);
+		if (image && image.getContext) {
+			this._image = null;
+			this._canvas = image;
+			this._loaded = true;
+		} else {
+			this._image = image;
+			this._canvas = null;
+			this._loaded = !!(image && image.src && image.complete);
+		}
+		this._size = new Size(
+				image ? image.naturalWidth || image.width : 0,
+				image ? image.naturalHeight || image.height : 0);
+		this._context = null;
+		this._changed(1033);
+	},
+
+	getCanvas: function() {
+		if (!this._canvas) {
+			var ctx = CanvasProvider.getContext(this._size);
+			try {
+				if (this._image)
+					ctx.drawImage(this._image, 0, 0);
+				this._canvas = ctx.canvas;
+			} catch (e) {
+				CanvasProvider.release(ctx);
+			}
+		}
+		return this._canvas;
+	},
+
+	setCanvas: '#setImage',
+
+	getContext: function(_change) {
+		if (!this._context)
+			this._context = this.getCanvas().getContext('2d');
+		if (_change) {
+			this._image = null;
+			this._changed(1025);
+		}
+		return this._context;
+	},
+
+	setContext: function(context) {
+		this._context = context;
+	},
+
+	getSource: function() {
+		var image = this._image;
+		return image && image.src || this.toDataURL();
+	},
+
+	setSource: function(src) {
+		var image = new self.Image(),
+			crossOrigin = this._crossOrigin;
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
+		if (src)
+			image.src = src;
+		this.setImage(image);
+	},
+
+	getCrossOrigin: function() {
+		var image = this._image;
+		return image && image.crossOrigin || this._crossOrigin || '';
+	},
+
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		var image = this._image;
+		if (image)
+			image.crossOrigin = crossOrigin;
+	},
+
+	getSmoothing: function() {
+		return this._smoothing;
+	},
+
+	setSmoothing: function(smoothing) {
+		this._smoothing = smoothing;
+		this._changed(257);
+	},
+
+	getElement: function() {
+		return this._canvas || this._loaded && this._image;
+	}
+}, {
+	beans: false,
+
+	getSubCanvas: function() {
+		var rect = Rectangle.read(arguments),
+			ctx = CanvasProvider.getContext(rect.getSize());
+		ctx.drawImage(this.getCanvas(), rect.x, rect.y,
+				rect.width, rect.height, 0, 0, rect.width, rect.height);
+		return ctx.canvas;
+	},
+
+	getSubRaster: function() {
+		var rect = Rectangle.read(arguments),
+			raster = new Raster(Item.NO_INSERT);
+		raster._setImage(this.getSubCanvas(rect));
+		raster.translate(rect.getCenter().subtract(this.getSize().divide(2)));
+		raster._matrix.prepend(this._matrix);
+		raster.insertAbove(this);
+		return raster;
+	},
+
+	toDataURL: function() {
+		var image = this._image,
+			src = image && image.src;
+		if (/^data:/.test(src))
+			return src;
+		var canvas = this.getCanvas();
+		return canvas ? canvas.toDataURL.apply(canvas, arguments) : null;
+	},
+
+	drawImage: function(image ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).drawImage(image, point.x, point.y);
+	},
+
+	getAverageColor: function(object) {
+		var bounds, path;
+		if (!object) {
+			bounds = this.getBounds();
+		} else if (object instanceof PathItem) {
+			path = object;
+			bounds = object.getBounds();
+		} else if (typeof object === 'object') {
+			if ('width' in object) {
+				bounds = new Rectangle(object);
+			} else if ('x' in object) {
+				bounds = new Rectangle(object.x - 0.5, object.y - 0.5, 1, 1);
+			}
+		}
+		if (!bounds)
+			return null;
+		var sampleSize = 32,
+			width = Math.min(bounds.width, sampleSize),
+			height = Math.min(bounds.height, sampleSize);
+		var ctx = Raster._sampleContext;
+		if (!ctx) {
+			ctx = Raster._sampleContext = CanvasProvider.getContext(
+					new Size(sampleSize));
+		} else {
+			ctx.clearRect(0, 0, sampleSize + 1, sampleSize + 1);
+		}
+		ctx.save();
+		var matrix = new Matrix()
+				.scale(width / bounds.width, height / bounds.height)
+				.translate(-bounds.x, -bounds.y);
+		matrix.applyToContext(ctx);
+		if (path)
+			path.draw(ctx, new Base({ clip: true, matrices: [matrix] }));
+		this._matrix.applyToContext(ctx);
+		var element = this.getElement(),
+			size = this._size;
+		if (element)
+			ctx.drawImage(element, -size.width / 2, -size.height / 2);
+		ctx.restore();
+		var pixels = ctx.getImageData(0.5, 0.5, Math.ceil(width),
+				Math.ceil(height)).data,
+			channels = [0, 0, 0],
+			total = 0;
+		for (var i = 0, l = pixels.length; i < l; i += 4) {
+			var alpha = pixels[i + 3];
+			total += alpha;
+			alpha /= 255;
+			channels[0] += pixels[i] * alpha;
+			channels[1] += pixels[i + 1] * alpha;
+			channels[2] += pixels[i + 2] * alpha;
+		}
+		for (var i = 0; i < 3; i++)
+			channels[i] /= total;
+		return total ? Color.read(channels) : null;
+	},
+
+	getPixel: function() {
+		var point = Point.read(arguments);
+		var data = this.getContext().getImageData(point.x, point.y, 1, 1).data;
+		return new Color('rgb', [data[0] / 255, data[1] / 255, data[2] / 255],
+				data[3] / 255);
+	},
+
+	setPixel: function() {
+		var args = arguments,
+			point = Point.read(args),
+			color = Color.read(args),
+			components = color._convert('rgb'),
+			alpha = color._alpha,
+			ctx = this.getContext(true),
+			imageData = ctx.createImageData(1, 1),
+			data = imageData.data;
+		data[0] = components[0] * 255;
+		data[1] = components[1] * 255;
+		data[2] = components[2] * 255;
+		data[3] = alpha != null ? alpha * 255 : 255;
+		ctx.putImageData(imageData, point.x, point.y);
+	},
+
+	clear: function() {
+		var size = this._size;
+		this.getContext(true).clearRect(0, 0, size.width + 1, size.height + 1);
+	},
+
+	createImageData: function() {
+		var size = Size.read(arguments);
+		return this.getContext().createImageData(size.width, size.height);
+	},
+
+	getImageData: function() {
+		var rect = Rectangle.read(arguments);
+		if (rect.isEmpty())
+			rect = new Rectangle(this._size);
+		return this.getContext().getImageData(rect.x, rect.y,
+				rect.width, rect.height);
+	},
+
+	setImageData: function(data ) {
+		var point = Point.read(arguments, 1);
+		this.getContext(true).putImageData(data, point.x, point.y);
+	},
+
+	_getBounds: function(matrix, options) {
+		var rect = new Rectangle(this._size).setCenter(0, 0);
+		return matrix ? matrix._transformBounds(rect) : rect;
+	},
+
+	_hitTestSelf: function(point) {
+		if (this._contains(point)) {
+			var that = this;
+			return new HitResult('pixel', that, {
+				offset: point.add(that._size.divide(2)).round(),
+				color: {
+					get: function() {
+						return that.getPixel(this.offset);
+					}
+				}
+			});
+		}
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		var element = this.getElement();
+		if (element && element.width > 0 && element.height > 0) {
+			ctx.globalAlpha = Numerical.clamp(this._opacity, 0, 1);
+
+			this._setStyles(ctx, param, viewMatrix);
+
+			DomElement.setPrefixed(
+				ctx, 'imageSmoothingEnabled', this._smoothing
+			);
+
+			ctx.drawImage(element,
+					-this._size.width / 2, -this._size.height / 2);
+		}
+	},
+
+	_canComposite: function() {
+		return true;
+	}
+});
+
+var SymbolItem = Item.extend({
+	_class: 'SymbolItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_boundsOptions: { stroke: true },
+	_serializeFields: {
+		symbol: null
+	},
+
+	initialize: function SymbolItem(arg0, arg1) {
+		if (!this._initialize(arg0,
+				arg1 !== undefined && Point.read(arguments, 1)))
+			this.setDefinition(arg0 instanceof SymbolDefinition ?
+					arg0 : new SymbolDefinition(arg0));
+	},
+
+	_equals: function(item) {
+		return this._definition === item._definition;
+	},
+
+	copyContent: function(source) {
+		this.setDefinition(source._definition);
+	},
+
+	getDefinition: function() {
+		return this._definition;
+	},
+
+	setDefinition: function(definition) {
+		this._definition = definition;
+		this._changed(9);
+	},
+
+	getSymbol: '#getDefinition',
+	setSymbol: '#setDefinition',
+
+	isEmpty: function() {
+		return this._definition._item.isEmpty();
+	},
+
+	_getBounds: function(matrix, options) {
+		var item = this._definition._item;
+		return item._getCachedBounds(item._matrix.prepended(matrix), options);
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix) {
+		var opts = options.extend({ all: false });
+		var res = this._definition._item._hitTest(point, opts, viewMatrix);
+		if (res)
+			res.item = this;
+		return res;
+	},
+
+	_draw: function(ctx, param) {
+		this._definition._item.draw(ctx, param);
+	}
+
+});
+
+var SymbolDefinition = Base.extend({
+	_class: 'SymbolDefinition',
+
+	initialize: function SymbolDefinition(item, dontCenter) {
+		this._id = UID.get();
+		this.project = paper.project;
+		if (item)
+			this.setItem(item, dontCenter);
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._class, this._item],
+					options, false, dictionary);
+		});
+	},
+
+	_changed: function(flags) {
+		if (flags & 8)
+			Item._clearBoundsCache(this);
+		if (flags & 1)
+			this.project._changed(flags);
+	},
+
+	getItem: function() {
+		return this._item;
+	},
+
+	setItem: function(item, _dontCenter) {
+		if (item._symbol)
+			item = item.clone();
+		if (this._item)
+			this._item._symbol = null;
+		this._item = item;
+		item.remove();
+		item.setSelected(false);
+		if (!_dontCenter)
+			item.setPosition(new Point());
+		item._symbol = this;
+		this._changed(9);
+	},
+
+	getDefinition: '#getItem',
+	setDefinition: '#setItem',
+
+	place: function(position) {
+		return new SymbolItem(this, position);
+	},
+
+	clone: function() {
+		return new SymbolDefinition(this._item.clone(false));
+	},
+
+	equals: function(symbol) {
+		return symbol === this
+				|| symbol && this._item.equals(symbol._item)
+				|| false;
+	}
+});
+
+var HitResult = Base.extend({
+	_class: 'HitResult',
+
+	initialize: function HitResult(type, item, values) {
+		this.type = type;
+		this.item = item;
+		if (values)
+			this.inject(values);
+	},
+
+	statics: {
+		getOptions: function(args) {
+			var options = args && Base.read(args);
+			return new Base({
+				type: null,
+				tolerance: paper.settings.hitTolerance,
+				fill: !options,
+				stroke: !options,
+				segments: !options,
+				handles: false,
+				ends: false,
+				position: false,
+				center: false,
+				bounds: false,
+				guides: false,
+				selected: false
+			}, options);
+		}
+	}
+});
+
+var Segment = Base.extend({
+	_class: 'Segment',
+	beans: true,
+	_selection: 0,
+
+	initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
+		var count = arguments.length,
+			point, handleIn, handleOut, selection;
+		if (count > 0) {
+			if (arg0 == null || typeof arg0 === 'object') {
+				if (count === 1 && arg0 && 'point' in arg0) {
+					point = arg0.point;
+					handleIn = arg0.handleIn;
+					handleOut = arg0.handleOut;
+					selection = arg0.selection;
+				} else {
+					point = arg0;
+					handleIn = arg1;
+					handleOut = arg2;
+					selection = arg3;
+				}
+			} else {
+				point = [ arg0, arg1 ];
+				handleIn = arg2 !== undefined ? [ arg2, arg3 ] : null;
+				handleOut = arg4 !== undefined ? [ arg4, arg5 ] : null;
+			}
+		}
+		new SegmentPoint(point, this, '_point');
+		new SegmentPoint(handleIn, this, '_handleIn');
+		new SegmentPoint(handleOut, this, '_handleOut');
+		if (selection)
+			this.setSelection(selection);
+	},
+
+	_serialize: function(options, dictionary) {
+		var point = this._point,
+			selection = this._selection,
+			obj = selection || this.hasHandles()
+					? [point, this._handleIn, this._handleOut]
+					: point;
+		if (selection)
+			obj.push(selection);
+		return Base.serialize(obj, options, true, dictionary);
+	},
+
+	_changed: function(point) {
+		var path = this._path;
+		if (!path)
+			return;
+		var curves = path._curves,
+			index = this._index,
+			curve;
+		if (curves) {
+			if ((!point || point === this._point || point === this._handleIn)
+					&& (curve = index > 0 ? curves[index - 1] : path._closed
+						? curves[curves.length - 1] : null))
+				curve._changed();
+			if ((!point || point === this._point || point === this._handleOut)
+					&& (curve = curves[index]))
+				curve._changed();
+		}
+		path._changed(41);
+	},
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	setPoint: function() {
+		this._point.set(Point.read(arguments));
+	},
+
+	getHandleIn: function() {
+		return this._handleIn;
+	},
+
+	setHandleIn: function() {
+		this._handleIn.set(Point.read(arguments));
+	},
+
+	getHandleOut: function() {
+		return this._handleOut;
+	},
+
+	setHandleOut: function() {
+		this._handleOut.set(Point.read(arguments));
+	},
+
+	hasHandles: function() {
+		return !this._handleIn.isZero() || !this._handleOut.isZero();
+	},
+
+	isSmooth: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut;
+		return !handleIn.isZero() && !handleOut.isZero()
+				&& handleIn.isCollinear(handleOut);
+	},
+
+	clearHandles: function() {
+		this._handleIn._set(0, 0);
+		this._handleOut._set(0, 0);
+	},
+
+	getSelection: function() {
+		return this._selection;
+	},
+
+	setSelection: function(selection) {
+		var oldSelection = this._selection,
+			path = this._path;
+		this._selection = selection = selection || 0;
+		if (path && selection !== oldSelection) {
+			path._updateSelection(this, oldSelection, selection);
+			path._changed(257);
+		}
+	},
+
+	_changeSelection: function(flag, selected) {
+		var selection = this._selection;
+		this.setSelection(selected ? selection | flag : selection & ~flag);
+	},
+
+	isSelected: function() {
+		return !!(this._selection & 7);
+	},
+
+	setSelected: function(selected) {
+		this._changeSelection(7, selected);
+	},
+
+	getIndex: function() {
+		return this._index !== undefined ? this._index : null;
+	},
+
+	getPath: function() {
+		return this._path || null;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			index = this._index;
+		if (path) {
+			if (index > 0 && !path._closed
+					&& index === path._segments.length - 1)
+				index--;
+			return path.getCurves()[index] || null;
+		}
+		return null;
+	},
+
+	getLocation: function() {
+		var curve = this.getCurve();
+		return curve
+				? new CurveLocation(curve, this === curve._segment1 ? 0 : 1)
+				: null;
+	},
+
+	getNext: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index + 1]
+				|| this._path._closed && segments[0]) || null;
+	},
+
+	smooth: function(options, _first, _last) {
+		var opts = options || {},
+			type = opts.type,
+			factor = opts.factor,
+			prev = this.getPrevious(),
+			next = this.getNext(),
+			p0 = (prev || this)._point,
+			p1 = this._point,
+			p2 = (next || this)._point,
+			d1 = p0.getDistance(p1),
+			d2 = p1.getDistance(p2);
+		if (!type || type === 'catmull-rom') {
+			var a = factor === undefined ? 0.5 : factor,
+				d1_a = Math.pow(d1, a),
+				d1_2a = d1_a * d1_a,
+				d2_a = Math.pow(d2, a),
+				d2_2a = d2_a * d2_a;
+			if (!_first && prev) {
+				var A = 2 * d2_2a + 3 * d2_a * d1_a + d1_2a,
+					N = 3 * d2_a * (d2_a + d1_a);
+				this.setHandleIn(N !== 0
+					? new Point(
+						(d2_2a * p0._x + A * p1._x - d1_2a * p2._x) / N - p1._x,
+						(d2_2a * p0._y + A * p1._y - d1_2a * p2._y) / N - p1._y)
+					: new Point());
+			}
+			if (!_last && next) {
+				var A = 2 * d1_2a + 3 * d1_a * d2_a + d2_2a,
+					N = 3 * d1_a * (d1_a + d2_a);
+				this.setHandleOut(N !== 0
+					? new Point(
+						(d1_2a * p2._x + A * p1._x - d2_2a * p0._x) / N - p1._x,
+						(d1_2a * p2._y + A * p1._y - d2_2a * p0._y) / N - p1._y)
+					: new Point());
+			}
+		} else if (type === 'geometric') {
+			if (prev && next) {
+				var vector = p0.subtract(p2),
+					t = factor === undefined ? 0.4 : factor,
+					k = t * d1 / (d1 + d2);
+				if (!_first)
+					this.setHandleIn(vector.multiply(k));
+				if (!_last)
+					this.setHandleOut(vector.multiply(k - t));
+			}
+		} else {
+			throw new Error('Smoothing method \'' + type + '\' not supported.');
+		}
+	},
+
+	getPrevious: function() {
+		var segments = this._path && this._path._segments;
+		return segments && (segments[this._index - 1]
+				|| this._path._closed && segments[segments.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._index === path._segments.length - 1 || false;
+	},
+
+	reverse: function() {
+		var handleIn = this._handleIn,
+			handleOut = this._handleOut,
+			tmp = handleIn.clone();
+		handleIn.set(handleOut);
+		handleOut.set(tmp);
+	},
+
+	reversed: function() {
+		return new Segment(this._point, this._handleOut, this._handleIn);
+	},
+
+	remove: function() {
+		return this._path ? !!this._path.removeSegment(this._index) : false;
+	},
+
+	clone: function() {
+		return new Segment(this._point, this._handleIn, this._handleOut);
+	},
+
+	equals: function(segment) {
+		return segment === this || segment && this._class === segment._class
+				&& this._point.equals(segment._point)
+				&& this._handleIn.equals(segment._handleIn)
+				&& this._handleOut.equals(segment._handleOut)
+				|| false;
+	},
+
+	toString: function() {
+		var parts = [ 'point: ' + this._point ];
+		if (!this._handleIn.isZero())
+			parts.push('handleIn: ' + this._handleIn);
+		if (!this._handleOut.isZero())
+			parts.push('handleOut: ' + this._handleOut);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	transform: function(matrix) {
+		this._transformCoordinates(matrix, new Array(6), true);
+		this._changed();
+	},
+
+	interpolate: function(from, to, factor) {
+		var u = 1 - factor,
+			v = factor,
+			point1 = from._point,
+			point2 = to._point,
+			handleIn1 = from._handleIn,
+			handleIn2 = to._handleIn,
+			handleOut2 = to._handleOut,
+			handleOut1 = from._handleOut;
+		this._point._set(
+				u * point1._x + v * point2._x,
+				u * point1._y + v * point2._y, true);
+		this._handleIn._set(
+				u * handleIn1._x + v * handleIn2._x,
+				u * handleIn1._y + v * handleIn2._y, true);
+		this._handleOut._set(
+				u * handleOut1._x + v * handleOut2._x,
+				u * handleOut1._y + v * handleOut2._y, true);
+		this._changed();
+	},
+
+	_transformCoordinates: function(matrix, coords, change) {
+		var point = this._point,
+			handleIn = !change || !this._handleIn.isZero()
+					? this._handleIn : null,
+			handleOut = !change || !this._handleOut.isZero()
+					? this._handleOut : null,
+			x = point._x,
+			y = point._y,
+			i = 2;
+		coords[0] = x;
+		coords[1] = y;
+		if (handleIn) {
+			coords[i++] = handleIn._x + x;
+			coords[i++] = handleIn._y + y;
+		}
+		if (handleOut) {
+			coords[i++] = handleOut._x + x;
+			coords[i++] = handleOut._y + y;
+		}
+		if (matrix) {
+			matrix._transformCoordinates(coords, coords, i / 2);
+			x = coords[0];
+			y = coords[1];
+			if (change) {
+				point._x = x;
+				point._y = y;
+				i = 2;
+				if (handleIn) {
+					handleIn._x = coords[i++] - x;
+					handleIn._y = coords[i++] - y;
+				}
+				if (handleOut) {
+					handleOut._x = coords[i++] - x;
+					handleOut._y = coords[i++] - y;
+				}
+			} else {
+				if (!handleIn) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+				if (!handleOut) {
+					coords[i++] = x;
+					coords[i++] = y;
+				}
+			}
+		}
+		return coords;
+	}
+});
+
+var SegmentPoint = Point.extend({
+	initialize: function SegmentPoint(point, owner, key) {
+		var x, y,
+			selected;
+		if (!point) {
+			x = y = 0;
+		} else if ((x = point[0]) !== undefined) {
+			y = point[1];
+		} else {
+			var pt = point;
+			if ((x = pt.x) === undefined) {
+				pt = Point.read(arguments);
+				x = pt.x;
+			}
+			y = pt.y;
+			selected = pt.selected;
+		}
+		this._x = x;
+		this._y = y;
+		this._owner = owner;
+		owner[key] = this;
+		if (selected)
+			this.setSelected(true);
+	},
+
+	_set: function(x, y) {
+		this._x = x;
+		this._y = y;
+		this._owner._changed(this);
+		return this;
+	},
+
+	getX: function() {
+		return this._x;
+	},
+
+	setX: function(x) {
+		this._x = x;
+		this._owner._changed(this);
+	},
+
+	getY: function() {
+		return this._y;
+	},
+
+	setY: function(y) {
+		this._y = y;
+		this._owner._changed(this);
+	},
+
+	isZero: function() {
+		var isZero = Numerical.isZero;
+		return isZero(this._x) && isZero(this._y);
+	},
+
+	isSelected: function() {
+		return !!(this._owner._selection & this._getSelection());
+	},
+
+	setSelected: function(selected) {
+		this._owner._changeSelection(this._getSelection(), selected);
+	},
+
+	_getSelection: function() {
+		var owner = this._owner;
+		return this === owner._point ? 1
+			: this === owner._handleIn ? 2
+			: this === owner._handleOut ? 4
+			: 0;
+	}
+});
+
+var Curve = Base.extend({
+	_class: 'Curve',
+	beans: true,
+
+	initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+		var count = arguments.length,
+			seg1, seg2,
+			point1, point2,
+			handle1, handle2;
+		if (count === 3) {
+			this._path = arg0;
+			seg1 = arg1;
+			seg2 = arg2;
+		} else if (!count) {
+			seg1 = new Segment();
+			seg2 = new Segment();
+		} else if (count === 1) {
+			if ('segment1' in arg0) {
+				seg1 = new Segment(arg0.segment1);
+				seg2 = new Segment(arg0.segment2);
+			} else if ('point1' in arg0) {
+				point1 = arg0.point1;
+				handle1 = arg0.handle1;
+				handle2 = arg0.handle2;
+				point2 = arg0.point2;
+			} else if (Array.isArray(arg0)) {
+				point1 = [arg0[0], arg0[1]];
+				point2 = [arg0[6], arg0[7]];
+				handle1 = [arg0[2] - arg0[0], arg0[3] - arg0[1]];
+				handle2 = [arg0[4] - arg0[6], arg0[5] - arg0[7]];
+			}
+		} else if (count === 2) {
+			seg1 = new Segment(arg0);
+			seg2 = new Segment(arg1);
+		} else if (count === 4) {
+			point1 = arg0;
+			handle1 = arg1;
+			handle2 = arg2;
+			point2 = arg3;
+		} else if (count === 8) {
+			point1 = [arg0, arg1];
+			point2 = [arg6, arg7];
+			handle1 = [arg2 - arg0, arg3 - arg1];
+			handle2 = [arg4 - arg6, arg5 - arg7];
+		}
+		this._segment1 = seg1 || new Segment(point1, null, handle1);
+		this._segment2 = seg2 || new Segment(point2, handle2, null);
+	},
+
+	_serialize: function(options, dictionary) {
+		return Base.serialize(this.hasHandles()
+				? [this.getPoint1(), this.getHandle1(), this.getHandle2(),
+					this.getPoint2()]
+				: [this.getPoint1(), this.getPoint2()],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		this._length = this._bounds = undefined;
+	},
+
+	clone: function() {
+		return new Curve(this._segment1, this._segment2);
+	},
+
+	toString: function() {
+		var parts = [ 'point1: ' + this._segment1._point ];
+		if (!this._segment1._handleOut.isZero())
+			parts.push('handle1: ' + this._segment1._handleOut);
+		if (!this._segment2._handleIn.isZero())
+			parts.push('handle2: ' + this._segment2._handleIn);
+		parts.push('point2: ' + this._segment2._point);
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	classify: function() {
+		return Curve.classify(this.getValues());
+	},
+
+	remove: function() {
+		var removed = false;
+		if (this._path) {
+			var segment2 = this._segment2,
+				handleOut = segment2._handleOut;
+			removed = segment2.remove();
+			if (removed)
+				this._segment1._handleOut.set(handleOut);
+		}
+		return removed;
+	},
+
+	getPoint1: function() {
+		return this._segment1._point;
+	},
+
+	setPoint1: function() {
+		this._segment1._point.set(Point.read(arguments));
+	},
+
+	getPoint2: function() {
+		return this._segment2._point;
+	},
+
+	setPoint2: function() {
+		this._segment2._point.set(Point.read(arguments));
+	},
+
+	getHandle1: function() {
+		return this._segment1._handleOut;
+	},
+
+	setHandle1: function() {
+		this._segment1._handleOut.set(Point.read(arguments));
+	},
+
+	getHandle2: function() {
+		return this._segment2._handleIn;
+	},
+
+	setHandle2: function() {
+		this._segment2._handleIn.set(Point.read(arguments));
+	},
+
+	getSegment1: function() {
+		return this._segment1;
+	},
+
+	getSegment2: function() {
+		return this._segment2;
+	},
+
+	getPath: function() {
+		return this._path;
+	},
+
+	getIndex: function() {
+		return this._segment1._index;
+	},
+
+	getNext: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index + 1]
+				|| this._path._closed && curves[0]) || null;
+	},
+
+	getPrevious: function() {
+		var curves = this._path && this._path._curves;
+		return curves && (curves[this._segment1._index - 1]
+				|| this._path._closed && curves[curves.length - 1]) || null;
+	},
+
+	isFirst: function() {
+		return !this._segment1._index;
+	},
+
+	isLast: function() {
+		var path = this._path;
+		return path && this._segment1._index === path._curves.length - 1
+				|| false;
+	},
+
+	isSelected: function() {
+		return this.getPoint1().isSelected()
+				&& this.getHandle1().isSelected()
+				&& this.getHandle2().isSelected()
+				&& this.getPoint2().isSelected();
+	},
+
+	setSelected: function(selected) {
+		this.getPoint1().setSelected(selected);
+		this.getHandle1().setSelected(selected);
+		this.getHandle2().setSelected(selected);
+		this.getPoint2().setSelected(selected);
+	},
+
+	getValues: function(matrix) {
+		return Curve.getValues(this._segment1, this._segment2, matrix);
+	},
+
+	getPoints: function() {
+		var coords = this.getValues(),
+			points = [];
+		for (var i = 0; i < 8; i += 2)
+			points.push(new Point(coords[i], coords[i + 1]));
+		return points;
+	}
+}, {
+	getLength: function() {
+		if (this._length == null)
+			this._length = Curve.getLength(this.getValues(), 0, 1);
+		return this._length;
+	},
+
+	getArea: function() {
+		return Curve.getArea(this.getValues());
+	},
+
+	getLine: function() {
+		return new Line(this._segment1._point, this._segment2._point);
+	},
+
+	getPart: function(from, to) {
+		return new Curve(Curve.getPart(this.getValues(), from, to));
+	},
+
+	getPartLength: function(from, to) {
+		return Curve.getLength(this.getValues(), from, to);
+	},
+
+	divideAt: function(location) {
+		return this.divideAtTime(location && location.curve === this
+				? location.time : this.getTimeAt(location));
+	},
+
+	divideAtTime: function(time, _setHandles) {
+		var tMin = 1e-8,
+			tMax = 1 - tMin,
+			res = null;
+		if (time >= tMin && time <= tMax) {
+			var parts = Curve.subdivide(this.getValues(), time),
+				left = parts[0],
+				right = parts[1],
+				setHandles = _setHandles || this.hasHandles(),
+				seg1 = this._segment1,
+				seg2 = this._segment2,
+				path = this._path;
+			if (setHandles) {
+				seg1._handleOut._set(left[2] - left[0], left[3] - left[1]);
+				seg2._handleIn._set(right[4] - right[6],right[5] - right[7]);
+			}
+			var x = left[6], y = left[7],
+				segment = new Segment(new Point(x, y),
+						setHandles && new Point(left[4] - x, left[5] - y),
+						setHandles && new Point(right[2] - x, right[3] - y));
+			if (path) {
+				path.insert(seg1._index + 1, segment);
+				res = this.getNext();
+			} else {
+				this._segment2 = segment;
+				this._changed();
+				res = new Curve(segment, seg2);
+			}
+		}
+		return res;
+	},
+
+	splitAt: function(location) {
+		var path = this._path;
+		return path ? path.splitAt(location) : null;
+	},
+
+	splitAtTime: function(time) {
+		return this.splitAt(this.getLocationAtTime(time));
+	},
+
+	divide: function(offset, isTime) {
+		return this.divideAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	split: function(offset, isTime) {
+		return this.splitAtTime(offset === undefined ? 0.5 : isTime ? offset
+				: this.getTimeAt(offset));
+	},
+
+	reversed: function() {
+		return new Curve(this._segment2.reversed(), this._segment1.reversed());
+	},
+
+	clearHandles: function() {
+		this._segment1._handleOut._set(0, 0);
+		this._segment2._handleIn._set(0, 0);
+	},
+
+statics: {
+	getValues: function(segment1, segment2, matrix, straight) {
+		var p1 = segment1._point,
+			h1 = segment1._handleOut,
+			h2 = segment2._handleIn,
+			p2 = segment2._point,
+			x1 = p1.x, y1 = p1.y,
+			x2 = p2.x, y2 = p2.y,
+			values = straight
+				? [ x1, y1, x1, y1, x2, y2, x2, y2 ]
+				: [
+					x1, y1,
+					x1 + h1._x, y1 + h1._y,
+					x2 + h2._x, y2 + h2._y,
+					x2, y2
+				];
+		if (matrix)
+			matrix._transformCoordinates(values, values, 4);
+		return values;
+	},
+
+	subdivide: function(v, t) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		if (t === undefined)
+			t = 0.5;
+		var u = 1 - t,
+			x4 = u * x0 + t * x1, y4 = u * y0 + t * y1,
+			x5 = u * x1 + t * x2, y5 = u * y1 + t * y2,
+			x6 = u * x2 + t * x3, y6 = u * y2 + t * y3,
+			x7 = u * x4 + t * x5, y7 = u * y4 + t * y5,
+			x8 = u * x5 + t * x6, y8 = u * y5 + t * y6,
+			x9 = u * x7 + t * x8, y9 = u * y7 + t * y8;
+		return [
+			[x0, y0, x4, y4, x7, y7, x9, y9],
+			[x9, y9, x8, y8, x6, y6, x3, y3]
+		];
+	},
+
+	getMonoCurves: function(v, dir) {
+		var curves = [],
+			io = dir ? 0 : 1,
+			o0 = v[io + 0],
+			o1 = v[io + 2],
+			o2 = v[io + 4],
+			o3 = v[io + 6];
+		if ((o0 >= o1) === (o1 >= o2) && (o1 >= o2) === (o2 >= o3)
+				|| Curve.isStraight(v)) {
+			curves.push(v);
+		} else {
+			var a = 3 * (o1 - o2) - o0 + o3,
+				b = 2 * (o0 + o2) - 4 * o1,
+				c = o1 - o0,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [],
+				n = Numerical.solveQuadratic(a, b, c, roots, tMin, tMax);
+			if (!n) {
+				curves.push(v);
+			} else {
+				roots.sort();
+				var t = roots[0],
+					parts = Curve.subdivide(v, t);
+				curves.push(parts[0]);
+				if (n > 1) {
+					t = (roots[1] - t) / (1 - t);
+					parts = Curve.subdivide(parts[1], t);
+					curves.push(parts[0]);
+				}
+				curves.push(parts[1]);
+			}
+		}
+		return curves;
+	},
+
+	solveCubic: function (v, coord, val, roots, min, max) {
+		var v0 = v[coord],
+			v1 = v[coord + 2],
+			v2 = v[coord + 4],
+			v3 = v[coord + 6],
+			res = 0;
+		if (  !(v0 < val && v3 < val && v1 < val && v2 < val ||
+				v0 > val && v3 > val && v1 > val && v2 > val)) {
+			var c = 3 * (v1 - v0),
+				b = 3 * (v2 - v1) - c,
+				a = v3 - v0 - c - b;
+			res = Numerical.solveCubic(a, b, c, v0 - val, roots, min, max);
+		}
+		return res;
+	},
+
+	getTimeOf: function(v, point) {
+		var p0 = new Point(v[0], v[1]),
+			p3 = new Point(v[6], v[7]),
+			epsilon = 1e-12,
+			geomEpsilon = 1e-7,
+			t = point.isClose(p0, epsilon) ? 0
+			  : point.isClose(p3, epsilon) ? 1
+			  : null;
+		if (t === null) {
+			var coords = [point.x, point.y],
+				roots = [];
+			for (var c = 0; c < 2; c++) {
+				var count = Curve.solveCubic(v, c, coords[c], roots, 0, 1);
+				for (var i = 0; i < count; i++) {
+					var u = roots[i];
+					if (point.isClose(Curve.getPoint(v, u), geomEpsilon))
+						return u;
+				}
+			}
+		}
+		return point.isClose(p0, geomEpsilon) ? 0
+			 : point.isClose(p3, geomEpsilon) ? 1
+			 : null;
+	},
+
+	getNearestTime: function(v, point) {
+		if (Curve.isStraight(v)) {
+			var x0 = v[0], y0 = v[1],
+				x3 = v[6], y3 = v[7],
+				vx = x3 - x0, vy = y3 - y0,
+				det = vx * vx + vy * vy;
+			if (det === 0)
+				return 0;
+			var u = ((point.x - x0) * vx + (point.y - y0) * vy) / det;
+			return u < 1e-12 ? 0
+				 : u > 0.999999999999 ? 1
+				 : Curve.getTimeOf(v,
+					new Point(x0 + u * vx, y0 + u * vy));
+		}
+
+		var count = 100,
+			minDist = Infinity,
+			minT = 0;
+
+		function refine(t) {
+			if (t >= 0 && t <= 1) {
+				var dist = point.getDistance(Curve.getPoint(v, t), true);
+				if (dist < minDist) {
+					minDist = dist;
+					minT = t;
+					return true;
+				}
+			}
+		}
+
+		for (var i = 0; i <= count; i++)
+			refine(i / count);
+
+		var step = 1 / (count * 2);
+		while (step > 1e-8) {
+			if (!refine(minT - step) && !refine(minT + step))
+				step /= 2;
+		}
+		return minT;
+	},
+
+	getPart: function(v, from, to) {
+		var flip = from > to;
+		if (flip) {
+			var tmp = from;
+			from = to;
+			to = tmp;
+		}
+		if (from > 0)
+			v = Curve.subdivide(v, from)[1];
+		if (to < 1)
+			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
+		return flip
+				? [v[6], v[7], v[4], v[5], v[2], v[3], v[0], v[1]]
+				: v;
+	},
+
+	isFlatEnough: function(v, flatness) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			ux = 3 * x1 - 2 * x0 - x3,
+			uy = 3 * y1 - 2 * y0 - y3,
+			vx = 3 * x2 - 2 * x3 - x0,
+			vy = 3 * y2 - 2 * y3 - y0;
+		return Math.max(ux * ux, vx * vx) + Math.max(uy * uy, vy * vy)
+				<= 16 * flatness * flatness;
+	},
+
+	getArea: function(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7];
+		return 3 * ((y3 - y0) * (x1 + x2) - (x3 - x0) * (y1 + y2)
+				+ y1 * (x0 - x2) - x1 * (y0 - y2)
+				+ y3 * (x2 + x0 / 3) - x3 * (y2 + y0 / 3)) / 20;
+	},
+
+	getBounds: function(v) {
+		var min = v.slice(0, 2),
+			max = min.slice(),
+			roots = [0, 0];
+		for (var i = 0; i < 2; i++)
+			Curve._addBounds(v[i], v[i + 2], v[i + 4], v[i + 6],
+					i, 0, min, max, roots);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	_addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
+		function add(value, padding) {
+			var left = value - padding,
+				right = value + padding;
+			if (left < min[coord])
+				min[coord] = left;
+			if (right > max[coord])
+				max[coord] = right;
+		}
+
+		padding /= 2;
+		var minPad = min[coord] - padding,
+			maxPad = max[coord] + padding;
+		if (    v0 < minPad || v1 < minPad || v2 < minPad || v3 < minPad ||
+				v0 > maxPad || v1 > maxPad || v2 > maxPad || v3 > maxPad) {
+			if (v1 < v0 != v1 < v3 && v2 < v0 != v2 < v3) {
+				add(v0, padding);
+				add(v3, padding);
+			} else {
+				var a = 3 * (v1 - v2) - v0 + v3,
+					b = 2 * (v0 + v2) - 4 * v1,
+					c = v1 - v0,
+					count = Numerical.solveQuadratic(a, b, c, roots),
+					tMin = 1e-8,
+					tMax = 1 - tMin;
+				add(v3, 0);
+				for (var i = 0; i < count; i++) {
+					var t = roots[i],
+						u = 1 - t;
+					if (tMin <= t && t <= tMax)
+						add(u * u * u * v0
+							+ 3 * u * u * t * v1
+							+ 3 * u * t * t * v2
+							+ t * t * t * v3,
+							padding);
+				}
+			}
+		}
+	}
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds'],
+	function(name) {
+		this[name] = function() {
+			if (!this._bounds)
+				this._bounds = {};
+			var bounds = this._bounds[name];
+			if (!bounds) {
+				bounds = this._bounds[name] = Path[name](
+						[this._segment1, this._segment2], false, this._path);
+			}
+			return bounds.clone();
+		};
+	},
+{
+
+}), Base.each({
+	isStraight: function(p1, h1, h2, p2) {
+		if (h1.isZero() && h2.isZero()) {
+			return true;
+		} else {
+			var v = p2.subtract(p1);
+			if (v.isZero()) {
+				return false;
+			} else if (v.isCollinear(h1) && v.isCollinear(h2)) {
+				var l = new Line(p1, p2),
+					epsilon = 1e-7;
+				if (l.getDistance(p1.add(h1)) < epsilon &&
+					l.getDistance(p2.add(h2)) < epsilon) {
+					var div = v.dot(v),
+						s1 = v.dot(h1) / div,
+						s2 = v.dot(h2) / div;
+					return s1 >= 0 && s1 <= 1 && s2 <= 0 && s2 >= -1;
+				}
+			}
+		}
+		return false;
+	},
+
+	isLinear: function(p1, h1, h2, p2) {
+		var third = p2.subtract(p1).divide(3);
+		return h1.equals(third) && h2.negate().equals(third);
+	}
+}, function(test, name) {
+	this[name] = function(epsilon) {
+		var seg1 = this._segment1,
+			seg2 = this._segment2;
+		return test(seg1._point, seg1._handleOut, seg2._handleIn, seg2._point,
+				epsilon);
+	};
+
+	this.statics[name] = function(v, epsilon) {
+		var x0 = v[0], y0 = v[1],
+			x3 = v[6], y3 = v[7];
+		return test(
+				new Point(x0, y0),
+				new Point(v[2] - x0, v[3] - y0),
+				new Point(v[4] - x3, v[5] - y3),
+				new Point(x3, y3), epsilon);
+	};
+}, {
+	statics: {},
+
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
+
+	hasLength: function(epsilon) {
+		return (!this.getPoint1().equals(this.getPoint2()) || this.hasHandles())
+				&& this.getLength() > (epsilon || 0);
+	},
+
+	isCollinear: function(curve) {
+		return curve && this.isStraight() && curve.isStraight()
+				&& this.getLine().isCollinear(curve.getLine());
+	},
+
+	isHorizontal: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).y)
+				< 1e-8;
+	},
+
+	isVertical: function() {
+		return this.isStraight() && Math.abs(this.getTangentAtTime(0.5).x)
+				< 1e-8;
+	}
+}), {
+	beans: false,
+
+	getLocationAt: function(offset, _isTime) {
+		return this.getLocationAtTime(
+				_isTime ? offset : this.getTimeAt(offset));
+	},
+
+	getLocationAtTime: function(t) {
+		return t != null && t >= 0 && t <= 1
+				? new CurveLocation(this, t)
+				: null;
+	},
+
+	getTimeAt: function(offset, start) {
+		return Curve.getTimeAt(this.getValues(), offset, start);
+	},
+
+	getParameterAt: '#getTimeAt',
+
+	getTimesWithTangent: function () {
+		var tangent = Point.read(arguments);
+		return tangent.isZero()
+				? []
+				: Curve.getTimesWithTangent(this.getValues(), tangent);
+	},
+
+	getOffsetAtTime: function(t) {
+		return this.getPartLength(0, t);
+	},
+
+	getLocationOf: function() {
+		return this.getLocationAtTime(this.getTimeOf(Point.read(arguments)));
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getTimeOf: function() {
+		return Curve.getTimeOf(this.getValues(), Point.read(arguments));
+	},
+
+	getParameterOf: '#getTimeOf',
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			values = this.getValues(),
+			t = Curve.getNearestTime(values, point),
+			pt = Curve.getPoint(values, t);
+		return new CurveLocation(this, t, pt, null, point.getDistance(pt));
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	}
+
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+		function(name) {
+			this[name + 'At'] = function(location, _isTime) {
+				var values = this.getValues();
+				return Curve[name](values, _isTime ? location
+						: Curve.getTimeAt(values, location));
+			};
+
+			this[name + 'AtTime'] = function(time) {
+				return Curve[name](this.getValues(), time);
+			};
+		}, {
+			statics: {
+				_evaluateMethods: methods
+			}
+		}
+	);
+},
+new function() {
+
+	function getLengthIntegrand(v) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+
+			ax = 9 * (x1 - x2) + 3 * (x3 - x0),
+			bx = 6 * (x0 + x2) - 12 * x1,
+			cx = 3 * (x1 - x0),
+
+			ay = 9 * (y1 - y2) + 3 * (y3 - y0),
+			by = 6 * (y0 + y2) - 12 * y1,
+			cy = 3 * (y1 - y0);
+
+		return function(t) {
+			var dx = (ax * t + bx) * t + cx,
+				dy = (ay * t + by) * t + cy;
+			return Math.sqrt(dx * dx + dy * dy);
+		};
+	}
+
+	function getIterations(a, b) {
+		return Math.max(2, Math.min(16, Math.ceil(Math.abs(b - a) * 32)));
+	}
+
+	function evaluate(v, t, type, normalized) {
+		if (t == null || t < 0 || t > 1)
+			return null;
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			isZero = Numerical.isZero;
+		if (isZero(x1 - x0) && isZero(y1 - y0)) {
+			x1 = x0;
+			y1 = y0;
+		}
+		if (isZero(x2 - x3) && isZero(y2 - y3)) {
+			x2 = x3;
+			y2 = y3;
+		}
+		var cx = 3 * (x1 - x0),
+			bx = 3 * (x2 - x1) - cx,
+			ax = x3 - x0 - cx - bx,
+			cy = 3 * (y1 - y0),
+			by = 3 * (y2 - y1) - cy,
+			ay = y3 - y0 - cy - by,
+			x, y;
+		if (type === 0) {
+			x = t === 0 ? x0 : t === 1 ? x3
+					: ((ax * t + bx) * t + cx) * t + x0;
+			y = t === 0 ? y0 : t === 1 ? y3
+					: ((ay * t + by) * t + cy) * t + y0;
+		} else {
+			var tMin = 1e-8,
+				tMax = 1 - tMin;
+			if (t < tMin) {
+				x = cx;
+				y = cy;
+			} else if (t > tMax) {
+				x = 3 * (x3 - x2);
+				y = 3 * (y3 - y2);
+			} else {
+				x = (3 * ax * t + 2 * bx) * t + cx;
+				y = (3 * ay * t + 2 * by) * t + cy;
+			}
+			if (normalized) {
+				if (x === 0 && y === 0 && (t < tMin || t > tMax)) {
+					x = x2 - x1;
+					y = y2 - y1;
+				}
+				var len = Math.sqrt(x * x + y * y);
+				if (len) {
+					x /= len;
+					y /= len;
+				}
+			}
+			if (type === 3) {
+				var x2 = 6 * ax * t + 2 * bx,
+					y2 = 6 * ay * t + 2 * by,
+					d = Math.pow(x * x + y * y, 3 / 2);
+				x = d !== 0 ? (x * y2 - y * x2) / d : 0;
+				y = 0;
+			}
+		}
+		return type === 2 ? new Point(y, -x) : new Point(x, y);
+	}
+
+	return { statics: {
+
+		classify: function(v) {
+
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				a1 = x0 * (y3 - y2) + y0 * (x2 - x3) + x3 * y2 - y3 * x2,
+				a2 = x1 * (y0 - y3) + y1 * (x3 - x0) + x0 * y3 - y0 * x3,
+				a3 = x2 * (y1 - y0) + y2 * (x0 - x1) + x1 * y0 - y1 * x0,
+				d3 = 3 * a3,
+				d2 = d3 - a2,
+				d1 = d2 - a2 + a1,
+				l = Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3),
+				s = l !== 0 ? 1 / l : 0,
+				isZero = Numerical.isZero,
+				serpentine = 'serpentine';
+			d1 *= s;
+			d2 *= s;
+			d3 *= s;
+
+			function type(type, t1, t2) {
+				var hasRoots = t1 !== undefined,
+					t1Ok = hasRoots && t1 > 0 && t1 < 1,
+					t2Ok = hasRoots && t2 > 0 && t2 < 1;
+				if (hasRoots && (!(t1Ok || t2Ok)
+						|| type === 'loop' && !(t1Ok && t2Ok))) {
+					type = 'arch';
+					t1Ok = t2Ok = false;
+				}
+				return {
+					type: type,
+					roots: t1Ok || t2Ok
+							? t1Ok && t2Ok
+								? t1 < t2 ? [t1, t2] : [t2, t1]
+								: [t1Ok ? t1 : t2]
+							: null
+				};
+			}
+
+			if (isZero(d1)) {
+				return isZero(d2)
+						? type(isZero(d3) ? 'line' : 'quadratic')
+						: type(serpentine, d3 / (3 * d2));
+			}
+			var d = 3 * d2 * d2 - 4 * d1 * d3;
+			if (isZero(d)) {
+				return type('cusp', d2 / (2 * d1));
+			}
+			var f1 = d > 0 ? Math.sqrt(d / 3) : Math.sqrt(-d),
+				f2 = 2 * d1;
+			return type(d > 0 ? serpentine : 'loop',
+					(d2 + f1) / f2,
+					(d2 - f1) / f2);
+		},
+
+		getLength: function(v, a, b, ds) {
+			if (a === undefined)
+				a = 0;
+			if (b === undefined)
+				b = 1;
+			if (Curve.isStraight(v)) {
+				var c = v;
+				if (b < 1) {
+					c = Curve.subdivide(c, b)[0];
+					a /= b;
+				}
+				if (a > 0) {
+					c = Curve.subdivide(c, a)[1];
+				}
+				var dx = c[6] - c[0],
+					dy = c[7] - c[1];
+				return Math.sqrt(dx * dx + dy * dy);
+			}
+			return Numerical.integrate(ds || getLengthIntegrand(v), a, b,
+					getIterations(a, b));
+		},
+
+		getTimeAt: function(v, offset, start) {
+			if (start === undefined)
+				start = offset < 0 ? 1 : 0;
+			if (offset === 0)
+				return start;
+			var abs = Math.abs,
+				epsilon = 1e-12,
+				forward = offset > 0,
+				a = forward ? start : 0,
+				b = forward ? 1 : start,
+				ds = getLengthIntegrand(v),
+				rangeLength = Curve.getLength(v, a, b, ds),
+				diff = abs(offset) - rangeLength;
+			if (abs(diff) < epsilon) {
+				return forward ? b : a;
+			} else if (diff > epsilon) {
+				return null;
+			}
+			var guess = offset / rangeLength,
+				length = 0;
+			function f(t) {
+				length += Numerical.integrate(ds, start, t,
+						getIterations(start, t));
+				start = t;
+				return length - offset;
+			}
+			return Numerical.findRoot(f, ds, start + guess, a, b, 32,
+					1e-12);
+		},
+
+		getPoint: function(v, t) {
+			return evaluate(v, t, 0, false);
+		},
+
+		getTangent: function(v, t) {
+			return evaluate(v, t, 1, true);
+		},
+
+		getWeightedTangent: function(v, t) {
+			return evaluate(v, t, 1, false);
+		},
+
+		getNormal: function(v, t) {
+			return evaluate(v, t, 2, true);
+		},
+
+		getWeightedNormal: function(v, t) {
+			return evaluate(v, t, 2, false);
+		},
+
+		getCurvature: function(v, t) {
+			return evaluate(v, t, 3, false).x;
+		},
+
+		getPeaks: function(v) {
+			var x0 = v[0], y0 = v[1],
+				x1 = v[2], y1 = v[3],
+				x2 = v[4], y2 = v[5],
+				x3 = v[6], y3 = v[7],
+				ax =     -x0 + 3 * x1 - 3 * x2 + x3,
+				bx =  3 * x0 - 6 * x1 + 3 * x2,
+				cx = -3 * x0 + 3 * x1,
+				ay =     -y0 + 3 * y1 - 3 * y2 + y3,
+				by =  3 * y0 - 6 * y1 + 3 * y2,
+				cy = -3 * y0 + 3 * y1,
+				tMin = 1e-8,
+				tMax = 1 - tMin,
+				roots = [];
+			Numerical.solveCubic(
+					9 * (ax * ax + ay * ay),
+					9 * (ax * bx + by * ay),
+					2 * (bx * bx + by * by) + 3 * (cx * ax + cy * ay),
+					(cx * bx + by * cy),
+					roots, tMin, tMax);
+			return roots.sort();
+		}
+	}};
+},
+new function() {
+
+	function addLocation(locations, include, c1, t1, c2, t2, overlap) {
+		var excludeStart = !overlap && c1.getPrevious() === c2,
+			excludeEnd = !overlap && c1 !== c2 && c1.getNext() === c2,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (t1 !== null && t1 >= (excludeStart ? tMin : 0) &&
+			t1 <= (excludeEnd ? tMax : 1)) {
+			if (t2 !== null && t2 >= (excludeEnd ? tMin : 0) &&
+				t2 <= (excludeStart ? tMax : 1)) {
+				var loc1 = new CurveLocation(c1, t1, null, overlap),
+					loc2 = new CurveLocation(c2, t2, null, overlap);
+				loc1._intersection = loc2;
+				loc2._intersection = loc1;
+				if (!include || include(loc1)) {
+					CurveLocation.insert(locations, loc1, true);
+				}
+			}
+		}
+	}
+
+	function addCurveIntersections(v1, v2, c1, c2, locations, include, flip,
+			recursion, calls, tMin, tMax, uMin, uMax) {
+		if (++calls >= 4096 || ++recursion >= 40)
+			return calls;
+		var fatLineEpsilon = 1e-9,
+			q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
+			getSignedDistance = Line.getSignedDistance,
+			d1 = getSignedDistance(q0x, q0y, q3x, q3y, v2[2], v2[3]),
+			d2 = getSignedDistance(q0x, q0y, q3x, q3y, v2[4], v2[5]),
+			factor = d1 * d2 > 0 ? 3 / 4 : 4 / 9,
+			dMin = factor * Math.min(0, d1, d2),
+			dMax = factor * Math.max(0, d1, d2),
+			dp0 = getSignedDistance(q0x, q0y, q3x, q3y, v1[0], v1[1]),
+			dp1 = getSignedDistance(q0x, q0y, q3x, q3y, v1[2], v1[3]),
+			dp2 = getSignedDistance(q0x, q0y, q3x, q3y, v1[4], v1[5]),
+			dp3 = getSignedDistance(q0x, q0y, q3x, q3y, v1[6], v1[7]),
+			hull = getConvexHull(dp0, dp1, dp2, dp3),
+			top = hull[0],
+			bottom = hull[1],
+			tMinClip,
+			tMaxClip;
+		if (d1 === 0 && d2 === 0
+				&& dp0 === 0 && dp1 === 0 && dp2 === 0 && dp3 === 0
+			|| (tMinClip = clipConvexHull(top, bottom, dMin, dMax)) == null
+			|| (tMaxClip = clipConvexHull(top.reverse(), bottom.reverse(),
+				dMin, dMax)) == null)
+			return calls;
+		var tMinNew = tMin + (tMax - tMin) * tMinClip,
+			tMaxNew = tMin + (tMax - tMin) * tMaxClip;
+		if (Math.max(uMax - uMin, tMaxNew - tMinNew) < fatLineEpsilon) {
+			var t = (tMinNew + tMaxNew) / 2,
+				u = (uMin + uMax) / 2;
+			addLocation(locations, include,
+					flip ? c2 : c1, flip ? u : t,
+					flip ? c1 : c2, flip ? t : u);
+		} else {
+			v1 = Curve.getPart(v1, tMinClip, tMaxClip);
+			var uDiff = uMax - uMin;
+			if (tMaxClip - tMinClip > 0.8) {
+				if (tMaxNew - tMinNew > uDiff) {
+					var parts = Curve.subdivide(v1, 0.5),
+						t = (tMinNew + tMaxNew) / 2;
+					calls = addCurveIntersections(
+							v2, parts[0], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, t);
+					calls = addCurveIntersections(
+							v2, parts[1], c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, t, tMaxNew);
+				} else {
+					var parts = Curve.subdivide(v2, 0.5),
+						u = (uMin + uMax) / 2;
+					calls = addCurveIntersections(
+							parts[0], v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, u, tMinNew, tMaxNew);
+					calls = addCurveIntersections(
+							parts[1], v1, c2, c1, locations, include, !flip,
+							recursion, calls, u, uMax, tMinNew, tMaxNew);
+				}
+			} else {
+				if (uDiff === 0 || uDiff >= fatLineEpsilon) {
+					calls = addCurveIntersections(
+							v2, v1, c2, c1, locations, include, !flip,
+							recursion, calls, uMin, uMax, tMinNew, tMaxNew);
+				} else {
+					calls = addCurveIntersections(
+							v1, v2, c1, c2, locations, include, flip,
+							recursion, calls, tMinNew, tMaxNew, uMin, uMax);
+				}
+			}
+		}
+		return calls;
+	}
+
+	function getConvexHull(dq0, dq1, dq2, dq3) {
+		var p0 = [ 0, dq0 ],
+			p1 = [ 1 / 3, dq1 ],
+			p2 = [ 2 / 3, dq2 ],
+			p3 = [ 1, dq3 ],
+			dist1 = dq1 - (2 * dq0 + dq3) / 3,
+			dist2 = dq2 - (dq0 + 2 * dq3) / 3,
+			hull;
+		if (dist1 * dist2 < 0) {
+			hull = [[p0, p1, p3], [p0, p2, p3]];
+		} else {
+			var distRatio = dist1 / dist2;
+			hull = [
+				distRatio >= 2 ? [p0, p1, p3]
+				: distRatio <= 0.5 ? [p0, p2, p3]
+				: [p0, p1, p2, p3],
+				[p0, p3]
+			];
+		}
+		return (dist1 || dist2) < 0 ? hull.reverse() : hull;
+	}
+
+	function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
+		if (hullTop[0][1] < dMin) {
+			return clipConvexHullPart(hullTop, true, dMin);
+		} else if (hullBottom[0][1] > dMax) {
+			return clipConvexHullPart(hullBottom, false, dMax);
+		} else {
+			return hullTop[0][0];
+		}
+	}
+
+	function clipConvexHullPart(part, top, threshold) {
+		var px = part[0][0],
+			py = part[0][1];
+		for (var i = 1, l = part.length; i < l; i++) {
+			var qx = part[i][0],
+				qy = part[i][1];
+			if (top ? qy >= threshold : qy <= threshold) {
+				return qy === threshold ? qx
+						: px + (threshold - py) * (qx - px) / (qy - py);
+			}
+			px = qx;
+			py = qy;
+		}
+		return null;
+	}
+
+	function getCurveLineIntersections(v, px, py, vx, vy) {
+		var isZero = Numerical.isZero;
+		if (isZero(vx) && isZero(vy)) {
+			var t = Curve.getTimeOf(v, new Point(px, py));
+			return t === null ? [] : [t];
+		}
+		var angle = Math.atan2(-vy, vx),
+			sin = Math.sin(angle),
+			cos = Math.cos(angle),
+			rv = [],
+			roots = [];
+		for (var i = 0; i < 8; i += 2) {
+			var x = v[i] - px,
+				y = v[i + 1] - py;
+			rv.push(
+				x * cos - y * sin,
+				x * sin + y * cos);
+		}
+		Curve.solveCubic(rv, 1, 0, roots, 0, 1);
+		return roots;
+	}
+
+	function addCurveLineIntersections(v1, v2, c1, c2, locations, include,
+			flip) {
+		var x1 = v2[0], y1 = v2[1],
+			x2 = v2[6], y2 = v2[7],
+			roots = getCurveLineIntersections(v1, x1, y1, x2 - x1, y2 - y1);
+		for (var i = 0, l = roots.length; i < l; i++) {
+			var t1 = roots[i],
+				p1 = Curve.getPoint(v1, t1),
+				t2 = Curve.getTimeOf(v2, p1);
+			if (t2 !== null) {
+				addLocation(locations, include,
+						flip ? c2 : c1, flip ? t2 : t1,
+						flip ? c1 : c2, flip ? t1 : t2);
+			}
+		}
+	}
+
+	function addLineIntersection(v1, v2, c1, c2, locations, include) {
+		var pt = Line.intersect(
+				v1[0], v1[1], v1[6], v1[7],
+				v2[0], v2[1], v2[6], v2[7]);
+		if (pt) {
+			addLocation(locations, include,
+					c1, Curve.getTimeOf(v1, pt),
+					c2, Curve.getTimeOf(v2, pt));
+		}
+	}
+
+	function getCurveIntersections(v1, v2, c1, c2, locations, include) {
+		var epsilon = 1e-12,
+			min = Math.min,
+			max = Math.max;
+
+		if (max(v1[0], v1[2], v1[4], v1[6]) + epsilon >
+			min(v2[0], v2[2], v2[4], v2[6]) &&
+			min(v1[0], v1[2], v1[4], v1[6]) - epsilon <
+			max(v2[0], v2[2], v2[4], v2[6]) &&
+			max(v1[1], v1[3], v1[5], v1[7]) + epsilon >
+			min(v2[1], v2[3], v2[5], v2[7]) &&
+			min(v1[1], v1[3], v1[5], v1[7]) - epsilon <
+			max(v2[1], v2[3], v2[5], v2[7])) {
+			var overlaps = getOverlaps(v1, v2);
+			if (overlaps) {
+				for (var i = 0; i < 2; i++) {
+					var overlap = overlaps[i];
+					addLocation(locations, include,
+							c1, overlap[0],
+							c2, overlap[1], true);
+				}
+			} else {
+				var straight1 = Curve.isStraight(v1),
+					straight2 = Curve.isStraight(v2),
+					straight = straight1 && straight2,
+					flip = straight1 && !straight2,
+					before = locations.length;
+				(straight
+					? addLineIntersection
+					: straight1 || straight2
+						? addCurveLineIntersections
+						: addCurveIntersections)(
+							flip ? v2 : v1, flip ? v1 : v2,
+							flip ? c2 : c1, flip ? c1 : c2,
+							locations, include, flip,
+							0, 0, 0, 1, 0, 1);
+				if (!straight || locations.length === before) {
+					for (var i = 0; i < 4; i++) {
+						var t1 = i >> 1,
+							t2 = i & 1,
+							i1 = t1 * 6,
+							i2 = t2 * 6,
+							p1 = new Point(v1[i1], v1[i1 + 1]),
+							p2 = new Point(v2[i2], v2[i2 + 1]);
+						if (p1.isClose(p2, epsilon)) {
+							addLocation(locations, include,
+									c1, t1,
+									c2, t2);
+						}
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getSelfIntersection(v1, c1, locations, include) {
+		var info = Curve.classify(v1);
+		if (info.type === 'loop') {
+			var roots = info.roots;
+			addLocation(locations, include,
+					c1, roots[0],
+					c1, roots[1]);
+		}
+	  return locations;
+	}
+
+	function getIntersections(curves1, curves2, include, matrix1, matrix2,
+			_returnFirst) {
+		var epsilon = 1e-7,
+			self = !curves2;
+		if (self)
+			curves2 = curves1;
+		var length1 = curves1.length,
+			length2 = curves2.length,
+			values1 = new Array(length1),
+			values2 = self ? values1 : new Array(length2),
+			locations = [];
+
+		for (var i = 0; i < length1; i++) {
+			values1[i] = curves1[i].getValues(matrix1);
+		}
+		if (!self) {
+			for (var i = 0; i < length2; i++) {
+				values2[i] = curves2[i].getValues(matrix2);
+			}
+		}
+		var boundsCollisions = CollisionDetection.findCurveBoundsCollisions(
+				values1, values2, epsilon);
+		for (var index1 = 0; index1 < length1; index1++) {
+			var curve1 = curves1[index1],
+				v1 = values1[index1];
+			if (self) {
+				getSelfIntersection(v1, curve1, locations, include);
+			}
+			var collisions1 = boundsCollisions[index1];
+			if (collisions1) {
+				for (var j = 0; j < collisions1.length; j++) {
+					if (_returnFirst && locations.length)
+						return locations;
+					var index2 = collisions1[j];
+					if (!self || index2 > index1) {
+						var curve2 = curves2[index2],
+							v2 = values2[index2];
+						getCurveIntersections(
+								v1, v2, curve1, curve2, locations, include);
+					}
+				}
+			}
+		}
+		return locations;
+	}
+
+	function getOverlaps(v1, v2) {
+
+		function getSquaredLineLength(v) {
+			var x = v[6] - v[0],
+				y = v[7] - v[1];
+			return x * x + y * y;
+		}
+
+		var abs = Math.abs,
+			getDistance = Line.getDistance,
+			timeEpsilon = 1e-8,
+			geomEpsilon = 1e-7,
+			straight1 = Curve.isStraight(v1),
+			straight2 = Curve.isStraight(v2),
+			straightBoth = straight1 && straight2,
+			flip = getSquaredLineLength(v1) < getSquaredLineLength(v2),
+			l1 = flip ? v2 : v1,
+			l2 = flip ? v1 : v2,
+			px = l1[0], py = l1[1],
+			vx = l1[6] - px, vy = l1[7] - py;
+		if (getDistance(px, py, vx, vy, l2[0], l2[1], true) < geomEpsilon &&
+			getDistance(px, py, vx, vy, l2[6], l2[7], true) < geomEpsilon) {
+			if (!straightBoth &&
+				getDistance(px, py, vx, vy, l1[2], l1[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l1[4], l1[5], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[2], l2[3], true) < geomEpsilon &&
+				getDistance(px, py, vx, vy, l2[4], l2[5], true) < geomEpsilon) {
+				straight1 = straight2 = straightBoth = true;
+			}
+		} else if (straightBoth) {
+			return null;
+		}
+		if (straight1 ^ straight2) {
+			return null;
+		}
+
+		var v = [v1, v2],
+			pairs = [];
+		for (var i = 0; i < 4 && pairs.length < 2; i++) {
+			var i1 = i & 1,
+				i2 = i1 ^ 1,
+				t1 = i >> 1,
+				t2 = Curve.getTimeOf(v[i1], new Point(
+					v[i2][t1 ? 6 : 0],
+					v[i2][t1 ? 7 : 1]));
+			if (t2 != null) {
+				var pair = i1 ? [t1, t2] : [t2, t1];
+				if (!pairs.length ||
+					abs(pair[0] - pairs[0][0]) > timeEpsilon &&
+					abs(pair[1] - pairs[0][1]) > timeEpsilon) {
+					pairs.push(pair);
+				}
+			}
+			if (i > 2 && !pairs.length)
+				break;
+		}
+		if (pairs.length !== 2) {
+			pairs = null;
+		} else if (!straightBoth) {
+			var o1 = Curve.getPart(v1, pairs[0][0], pairs[1][0]),
+				o2 = Curve.getPart(v2, pairs[0][1], pairs[1][1]);
+			if (abs(o2[2] - o1[2]) > geomEpsilon ||
+				abs(o2[3] - o1[3]) > geomEpsilon ||
+				abs(o2[4] - o1[4]) > geomEpsilon ||
+				abs(o2[5] - o1[5]) > geomEpsilon)
+				pairs = null;
+		}
+		return pairs;
+	}
+
+	function getTimesWithTangent(v, tangent) {
+		var x0 = v[0], y0 = v[1],
+			x1 = v[2], y1 = v[3],
+			x2 = v[4], y2 = v[5],
+			x3 = v[6], y3 = v[7],
+			normalized = tangent.normalize(),
+			tx = normalized.x,
+			ty = normalized.y,
+			ax = 3 * x3 - 9 * x2 + 9 * x1 - 3 * x0,
+			ay = 3 * y3 - 9 * y2 + 9 * y1 - 3 * y0,
+			bx = 6 * x2 - 12 * x1 + 6 * x0,
+			by = 6 * y2 - 12 * y1 + 6 * y0,
+			cx = 3 * x1 - 3 * x0,
+			cy = 3 * y1 - 3 * y0,
+			den = 2 * ax * ty - 2 * ay * tx,
+			times = [];
+		if (Math.abs(den) < Numerical.CURVETIME_EPSILON) {
+			var num = ax * cy - ay * cx,
+				den = ax * by - ay * bx;
+			if (den != 0) {
+				var t = -num / den;
+				if (t >= 0 && t <= 1) times.push(t);
+			}
+		} else {
+			var delta = (bx * bx - 4 * ax * cx) * ty * ty +
+				(-2 * bx * by + 4 * ay * cx + 4 * ax * cy) * tx * ty +
+				(by * by - 4 * ay * cy) * tx * tx,
+				k = bx * ty - by * tx;
+			if (delta >= 0 && den != 0) {
+				var d = Math.sqrt(delta),
+					t0 = -(k + d) / den,
+					t1 = (-k + d) / den;
+				if (t0 >= 0 && t0 <= 1) times.push(t0);
+				if (t1 >= 0 && t1 <= 1) times.push(t1);
+			}
+		}
+		return times;
+	}
+
+	return {
+		getIntersections: function(curve) {
+			var v1 = this.getValues(),
+				v2 = curve && curve !== this && curve.getValues();
+			return v2 ? getCurveIntersections(v1, v2, this, curve, [])
+					  : getSelfIntersection(v1, this, []);
+		},
+
+		statics: {
+			getOverlaps: getOverlaps,
+			getIntersections: getIntersections,
+			getCurveLineIntersections: getCurveLineIntersections,
+			getTimesWithTangent: getTimesWithTangent
+		}
+	};
+});
+
+var CurveLocation = Base.extend({
+	_class: 'CurveLocation',
+
+	initialize: function CurveLocation(curve, time, point, _overlap, _distance) {
+		if (time >= 0.99999999) {
+			var next = curve.getNext();
+			if (next) {
+				time = 0;
+				curve = next;
+			}
+		}
+		this._setCurve(curve);
+		this._time = time;
+		this._point = point || curve.getPointAtTime(time);
+		this._overlap = _overlap;
+		this._distance = _distance;
+		this._intersection = this._next = this._previous = null;
+	},
+
+	_setPath: function(path) {
+		this._path = path;
+		this._version = path ? path._version : 0;
+	},
+
+	_setCurve: function(curve) {
+		this._setPath(curve._path);
+		this._curve = curve;
+		this._segment = null;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
+	},
+
+	_setSegment: function(segment) {
+		var curve = segment.getCurve();
+		if (curve) {
+			this._setCurve(curve);
+		} else {
+			this._setPath(segment._path);
+			this._segment1 = segment;
+			this._segment2 = null;
+		}
+		this._segment = segment;
+		this._time = segment === this._segment1 ? 0 : 1;
+		this._point = segment._point.clone();
+	},
+
+	getSegment: function() {
+		var segment = this._segment;
+		if (!segment) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			if (time === 0) {
+				segment = curve._segment1;
+			} else if (time === 1) {
+				segment = curve._segment2;
+			} else if (time != null) {
+				segment = curve.getPartLength(0, time)
+					< curve.getPartLength(time, 1)
+						? curve._segment1
+						: curve._segment2;
+			}
+			this._segment = segment;
+		}
+		return segment;
+	},
+
+	getCurve: function() {
+		var path = this._path,
+			that = this;
+		if (path && path._version !== this._version) {
+			this._time = this._offset = this._curveOffset = this._curve = null;
+		}
+
+		function trySegment(segment) {
+			var curve = segment && segment.getCurve();
+			if (curve && (that._time = curve.getTimeOf(that._point)) != null) {
+				that._setCurve(curve);
+				return curve;
+			}
+		}
+
+		return this._curve
+			|| trySegment(this._segment)
+			|| trySegment(this._segment1)
+			|| trySegment(this._segment2.getPrevious());
+	},
+
+	getPath: function() {
+		var curve = this.getCurve();
+		return curve && curve._path;
+	},
+
+	getIndex: function() {
+		var curve = this.getCurve();
+		return curve && curve.getIndex();
+	},
+
+	getTime: function() {
+		var curve = this.getCurve(),
+			time = this._time;
+		return curve && time == null
+			? this._time = curve.getTimeOf(this._point)
+			: time;
+	},
+
+	getParameter: '#getTime',
+
+	getPoint: function() {
+		return this._point;
+	},
+
+	getOffset: function() {
+		var offset = this._offset;
+		if (offset == null) {
+			offset = 0;
+			var path = this.getPath(),
+				index = this.getIndex();
+			if (path && index != null) {
+				var curves = path.getCurves();
+				for (var i = 0; i < index; i++)
+					offset += curves[i].getLength();
+			}
+			this._offset = offset += this.getCurveOffset();
+		}
+		return offset;
+	},
+
+	getCurveOffset: function() {
+		var offset = this._curveOffset;
+		if (offset == null) {
+			var curve = this.getCurve(),
+				time = this.getTime();
+			this._curveOffset = offset = time != null && curve
+					&& curve.getPartLength(0, time);
+		}
+		return offset;
+	},
+
+	getIntersection: function() {
+		return this._intersection;
+	},
+
+	getDistance: function() {
+		return this._distance;
+	},
+
+	divide: function() {
+		var curve = this.getCurve(),
+			res = curve && curve.divideAtTime(this.getTime());
+		if (res) {
+			this._setSegment(res._segment1);
+		}
+		return res;
+	},
+
+	split: function() {
+		var curve = this.getCurve(),
+			path = curve._path,
+			res = curve && curve.splitAtTime(this.getTime());
+		if (res) {
+			this._setSegment(path.getLastSegment());
+		}
+		return  res;
+	},
+
+	equals: function(loc, _ignoreOther) {
+		var res = this === loc;
+		if (!res && loc instanceof CurveLocation) {
+			var c1 = this.getCurve(),
+				c2 = loc.getCurve(),
+				p1 = c1._path,
+				p2 = c2._path;
+			if (p1 === p2) {
+				var abs = Math.abs,
+					epsilon = 1e-7,
+					diff = abs(this.getOffset() - loc.getOffset()),
+					i1 = !_ignoreOther && this._intersection,
+					i2 = !_ignoreOther && loc._intersection;
+				res = (diff < epsilon
+						|| p1 && abs(p1.getLength() - diff) < epsilon)
+					&& (!i1 && !i2 || i1 && i2 && i1.equals(i2, true));
+			}
+		}
+		return res;
+	},
+
+	toString: function() {
+		var parts = [],
+			point = this.getPoint(),
+			f = Formatter.instance;
+		if (point)
+			parts.push('point: ' + point);
+		var index = this.getIndex();
+		if (index != null)
+			parts.push('index: ' + index);
+		var time = this.getTime();
+		if (time != null)
+			parts.push('time: ' + f.number(time));
+		if (this._distance != null)
+			parts.push('distance: ' + f.number(this._distance));
+		return '{ ' + parts.join(', ') + ' }';
+	},
+
+	isTouching: function() {
+		var inter = this._intersection;
+		if (inter && this.getTangent().isCollinear(inter.getTangent())) {
+			var curve1 = this.getCurve(),
+				curve2 = inter.getCurve();
+			return !(curve1.isStraight() && curve2.isStraight()
+					&& curve1.getLine().intersect(curve2.getLine()));
+		}
+		return false;
+	},
+
+	isCrossing: function() {
+		var inter = this._intersection;
+		if (!inter)
+			return false;
+		var t1 = this.getTime(),
+			t2 = inter.getTime(),
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			t1Inside = t1 >= tMin && t1 <= tMax,
+			t2Inside = t2 >= tMin && t2 <= tMax;
+		if (t1Inside && t2Inside)
+			return !this.isTouching();
+		var c2 = this.getCurve(),
+			c1 = c2 && t1 < tMin ? c2.getPrevious() : c2,
+			c4 = inter.getCurve(),
+			c3 = c4 && t2 < tMin ? c4.getPrevious() : c4;
+		if (t1 > tMax)
+			c2 = c2.getNext();
+		if (t2 > tMax)
+			c4 = c4.getNext();
+		if (!c1 || !c2 || !c3 || !c4)
+			return false;
+
+		var offsets = [];
+
+		function addOffsets(curve, end) {
+			var v = curve.getValues(),
+				roots = Curve.classify(v).roots || Curve.getPeaks(v),
+				count = roots.length,
+				offset = Curve.getLength(v,
+					end && count ? roots[count - 1] : 0,
+					!end && count ? roots[0] : 1);
+			offsets.push(count ? offset : offset / 32);
+		}
+
+		function isInRange(angle, min, max) {
+			return min < max
+					? angle > min && angle < max
+					: angle > min || angle < max;
+		}
+
+		if (!t1Inside) {
+			addOffsets(c1, true);
+			addOffsets(c2, false);
+		}
+		if (!t2Inside) {
+			addOffsets(c3, true);
+			addOffsets(c4, false);
+		}
+		var pt = this.getPoint(),
+			offset = Math.min.apply(Math, offsets),
+			v2 = t1Inside ? c2.getTangentAtTime(t1)
+					: c2.getPointAt(offset).subtract(pt),
+			v1 = t1Inside ? v2.negate()
+					: c1.getPointAt(-offset).subtract(pt),
+			v4 = t2Inside ? c4.getTangentAtTime(t2)
+					: c4.getPointAt(offset).subtract(pt),
+			v3 = t2Inside ? v4.negate()
+					: c3.getPointAt(-offset).subtract(pt),
+			a1 = v1.getAngle(),
+			a2 = v2.getAngle(),
+			a3 = v3.getAngle(),
+			a4 = v4.getAngle();
+		return !!(t1Inside
+				? (isInRange(a1, a3, a4) ^ isInRange(a2, a3, a4)) &&
+				  (isInRange(a1, a4, a3) ^ isInRange(a2, a4, a3))
+				: (isInRange(a3, a1, a2) ^ isInRange(a4, a1, a2)) &&
+				  (isInRange(a3, a2, a1) ^ isInRange(a4, a2, a1)));
+	},
+
+	hasOverlap: function() {
+		return !!this._overlap;
+	}
+}, Base.each(Curve._evaluateMethods, function(name) {
+	var get = name + 'At';
+	this[name] = function() {
+		var curve = this.getCurve(),
+			time = this.getTime();
+		return time != null && curve && curve[get](time, true);
+	};
+}, {
+	preserve: true
+}),
+new function() {
+
+	function insert(locations, loc, merge) {
+		var length = locations.length,
+			l = 0,
+			r = length - 1;
+
+		function search(index, dir) {
+			for (var i = index + dir; i >= -1 && i <= length; i += dir) {
+				var loc2 = locations[((i % length) + length) % length];
+				if (!loc.getPoint().isClose(loc2.getPoint(),
+						1e-7))
+					break;
+				if (loc.equals(loc2))
+					return loc2;
+			}
+			return null;
+		}
+
+		while (l <= r) {
+			var m = (l + r) >>> 1,
+				loc2 = locations[m],
+				found;
+			if (merge && (found = loc.equals(loc2) ? loc2
+					: (search(m, -1) || search(m, 1)))) {
+				if (loc._overlap) {
+					found._overlap = found._intersection._overlap = true;
+				}
+				return found;
+			}
+		var path1 = loc.getPath(),
+			path2 = loc2.getPath(),
+			diff = path1 !== path2
+				? path1._id - path2._id
+				: (loc.getIndex() + loc.getTime())
+				- (loc2.getIndex() + loc2.getTime());
+			if (diff < 0) {
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		locations.splice(l, 0, loc);
+		return loc;
+	}
+
+	return { statics: {
+		insert: insert,
+
+		expand: function(locations) {
+			var expanded = locations.slice();
+			for (var i = locations.length - 1; i >= 0; i--) {
+				insert(expanded, locations[i]._intersection, false);
+			}
+			return expanded;
+		}
+	}};
+});
+
+var PathItem = Item.extend({
+	_class: 'PathItem',
+	_selectBounds: false,
+	_canScaleStroke: true,
+	beans: true,
+
+	initialize: function PathItem() {
+	},
+
+	statics: {
+		create: function(arg) {
+			var data,
+				segments,
+				compound;
+			if (Base.isPlainObject(arg)) {
+				segments = arg.segments;
+				data = arg.pathData;
+			} else if (Array.isArray(arg)) {
+				segments = arg;
+			} else if (typeof arg === 'string') {
+				data = arg;
+			}
+			if (segments) {
+				var first = segments[0];
+				compound = first && Array.isArray(first[0]);
+			} else if (data) {
+				compound = (data.match(/m/gi) || []).length > 1
+						|| /z\s*\S+/i.test(data);
+			}
+			var ctor = compound ? CompoundPath : Path;
+			return new ctor(arg);
+		}
+	},
+
+	_asPathItem: function() {
+		return this;
+	},
+
+	isClockwise: function() {
+		return this.getArea() >= 0;
+	},
+
+	setClockwise: function(clockwise) {
+		if (this.isClockwise() != (clockwise = !!clockwise))
+			this.reverse();
+	},
+
+	setPathData: function(data) {
+
+		var parts = data && data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
+			coords,
+			relative = false,
+			previous,
+			control,
+			current = new Point(),
+			start = new Point();
+
+		function getCoord(index, coord) {
+			var val = +coords[index];
+			if (relative)
+				val += current[coord];
+			return val;
+		}
+
+		function getPoint(index) {
+			return new Point(
+				getCoord(index, 'x'),
+				getCoord(index + 1, 'y')
+			);
+		}
+
+		this.clear();
+
+		for (var i = 0, l = parts && parts.length; i < l; i++) {
+			var part = parts[i],
+				command = part[0],
+				lower = command.toLowerCase();
+			coords = part.match(/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g);
+			var length = coords && coords.length;
+			relative = command === lower;
+			if (previous === 'z' && !/[mz]/.test(lower))
+				this.moveTo(current);
+			switch (lower) {
+			case 'm':
+			case 'l':
+				var move = lower === 'm';
+				for (var j = 0; j < length; j += 2) {
+					this[move ? 'moveTo' : 'lineTo'](current = getPoint(j));
+					if (move) {
+						start = current;
+						move = false;
+					}
+				}
+				control = current;
+				break;
+			case 'h':
+			case 'v':
+				var coord = lower === 'h' ? 'x' : 'y';
+				current = current.clone();
+				for (var j = 0; j < length; j++) {
+					current[coord] = getCoord(j, coord);
+					this.lineTo(current);
+				}
+				control = current;
+				break;
+			case 'c':
+				for (var j = 0; j < length; j += 6) {
+					this.cubicCurveTo(
+							getPoint(j),
+							control = getPoint(j + 2),
+							current = getPoint(j + 4));
+				}
+				break;
+			case 's':
+				for (var j = 0; j < length; j += 4) {
+					this.cubicCurveTo(
+							/[cs]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current,
+							control = getPoint(j),
+							current = getPoint(j + 2));
+					previous = lower;
+				}
+				break;
+			case 'q':
+				for (var j = 0; j < length; j += 4) {
+					this.quadraticCurveTo(
+							control = getPoint(j),
+							current = getPoint(j + 2));
+				}
+				break;
+			case 't':
+				for (var j = 0; j < length; j += 2) {
+					this.quadraticCurveTo(
+							control = (/[qt]/.test(previous)
+									? current.multiply(2).subtract(control)
+									: current),
+							current = getPoint(j));
+					previous = lower;
+				}
+				break;
+			case 'a':
+				for (var j = 0; j < length; j += 7) {
+					this.arcTo(current = getPoint(j + 5),
+							new Size(+coords[j], +coords[j + 1]),
+							+coords[j + 2], +coords[j + 4], +coords[j + 3]);
+				}
+				break;
+			case 'z':
+				this.closePath(1e-12);
+				current = start;
+				break;
+			}
+			previous = lower;
+		}
+	},
+
+	_canComposite: function() {
+		return !(this.hasFill() && this.hasStroke());
+	},
+
+	_contains: function(point) {
+		var winding = point.isInside(
+				this.getBounds({ internal: true, handle: true }))
+					? this._getWinding(point)
+					: {};
+		return winding.onPath || !!(this.getFillRule() === 'evenodd'
+				? winding.windingL & 1 || winding.windingR & 1
+				: winding.winding);
+	},
+
+	getIntersections: function(path, include, _matrix, _returnFirst) {
+		var self = this === path || !path,
+			matrix1 = this._matrix._orNullIfIdentity(),
+			matrix2 = self ? matrix1
+				: (_matrix || path._matrix)._orNullIfIdentity();
+		return self || this.getBounds(matrix1).intersects(
+				path.getBounds(matrix2), 1e-12)
+				? Curve.getIntersections(
+						this.getCurves(), !self && path.getCurves(), include,
+						matrix1, matrix2, _returnFirst)
+				: [];
+	},
+
+	getCrossings: function(path) {
+		return this.getIntersections(path, function(inter) {
+			return inter.isCrossing();
+		});
+	},
+
+	getNearestLocation: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves(),
+			minDist = Infinity,
+			minLoc = null;
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getNearestLocation(point);
+			if (loc._distance < minDist) {
+				minDist = loc._distance;
+				minLoc = loc;
+			}
+		}
+		return minLoc;
+	},
+
+	getNearestPoint: function() {
+		var loc = this.getNearestLocation.apply(this, arguments);
+		return loc ? loc.getPoint() : loc;
+	},
+
+	interpolate: function(from, to, factor) {
+		var isPath = !this._children,
+			name = isPath ? '_segments' : '_children',
+			itemsFrom = from[name],
+			itemsTo = to[name],
+			items = this[name];
+		if (!itemsFrom || !itemsTo || itemsFrom.length !== itemsTo.length) {
+			throw new Error('Invalid operands in interpolate() call: ' +
+					from + ', ' + to);
+		}
+		var current = items.length,
+			length = itemsTo.length;
+		if (current < length) {
+			var ctor = isPath ? Segment : Path;
+			for (var i = current; i < length; i++) {
+				this.add(new ctor());
+			}
+		} else if (current > length) {
+			this[isPath ? 'removeSegments' : 'removeChildren'](length, current);
+		}
+		for (var i = 0; i < length; i++) {
+			items[i].interpolate(itemsFrom[i], itemsTo[i], factor);
+		}
+		if (isPath) {
+			this.setClosed(from._closed);
+			this._changed(9);
+		}
+	},
+
+	compare: function(path) {
+		var ok = false;
+		if (path) {
+			var paths1 = this._children || [this],
+				paths2 = path._children ? path._children.slice() : [path],
+				length1 = paths1.length,
+				length2 = paths2.length,
+				matched = [],
+				count = 0;
+			ok = true;
+			var boundsOverlaps = CollisionDetection.findItemBoundsCollisions(paths1, paths2, Numerical.GEOMETRIC_EPSILON);
+			for (var i1 = length1 - 1; i1 >= 0 && ok; i1--) {
+				var path1 = paths1[i1];
+				ok = false;
+				var pathBoundsOverlaps = boundsOverlaps[i1];
+				if (pathBoundsOverlaps) {
+					for (var i2 = pathBoundsOverlaps.length - 1; i2 >= 0 && !ok; i2--) {
+						if (path1.compare(paths2[pathBoundsOverlaps[i2]])) {
+							if (!matched[pathBoundsOverlaps[i2]]) {
+								matched[pathBoundsOverlaps[i2]] = true;
+								count++;
+							}
+							ok = true;
+						}
+					}
+				}
+			}
+			ok = ok && count === length2;
+		}
+		return ok;
+	},
+
+});
+
+var Path = PathItem.extend({
+	_class: 'Path',
+	_serializeFields: {
+		segments: [],
+		closed: false
+	},
+
+	initialize: function Path(arg) {
+		this._closed = false;
+		this._segments = [];
+		this._version = 0;
+		var args = arguments,
+			segments = Array.isArray(arg)
+			? typeof arg[0] === 'object'
+				? arg
+				: args
+			: arg && (arg.size === undefined && (arg.x !== undefined
+					|| arg.point !== undefined))
+				? args
+				: null;
+		if (segments && segments.length > 0) {
+			this.setSegments(segments);
+		} else {
+			this._curves = undefined;
+			this._segmentSelection = 0;
+			if (!segments && typeof arg === 'string') {
+				this.setPathData(arg);
+				arg = null;
+			}
+		}
+		this._initialize(!segments && arg);
+	},
+
+	_equals: function(item) {
+		return this._closed === item._closed
+				&& Base.equals(this._segments, item._segments);
+	},
+
+	copyContent: function(source) {
+		this.setSegments(source._segments);
+		this._closed = source._closed;
+	},
+
+	_changed: function _changed(flags) {
+		_changed.base.call(this, flags);
+		if (flags & 8) {
+			this._length = this._area = undefined;
+			if (flags & 32) {
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
+					this._curves[i]._changed();
+			}
+		} else if (flags & 64) {
+			this._bounds = undefined;
+		}
+	},
+
+	getStyle: function() {
+		var parent = this._parent;
+		return (parent instanceof CompoundPath ? parent : this)._style;
+	},
+
+	getSegments: function() {
+		return this._segments;
+	},
+
+	setSegments: function(segments) {
+		var fullySelected = this.isFullySelected(),
+			length = segments && segments.length;
+		this._segments.length = 0;
+		this._segmentSelection = 0;
+		this._curves = undefined;
+		if (length) {
+			var last = segments[length - 1];
+			if (typeof last === 'boolean') {
+				this.setClosed(last);
+				length--;
+			}
+			this._add(Segment.readList(segments, 0, {}, length));
+		}
+		if (fullySelected)
+			this.setFullySelected(true);
+	},
+
+	getFirstSegment: function() {
+		return this._segments[0];
+	},
+
+	getLastSegment: function() {
+		return this._segments[this._segments.length - 1];
+	},
+
+	getCurves: function() {
+		var curves = this._curves,
+			segments = this._segments;
+		if (!curves) {
+			var length = this._countCurves();
+			curves = this._curves = new Array(length);
+			for (var i = 0; i < length; i++)
+				curves[i] = new Curve(this, segments[i],
+					segments[i + 1] || segments[0]);
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		return this.getCurves()[0];
+	},
+
+	getLastCurve: function() {
+		var curves = this.getCurves();
+		return curves[curves.length - 1];
+	},
+
+	isClosed: function() {
+		return this._closed;
+	},
+
+	setClosed: function(closed) {
+		if (this._closed != (closed = !!closed)) {
+			this._closed = closed;
+			if (this._curves) {
+				var length = this._curves.length = this._countCurves();
+				if (closed)
+					this._curves[length - 1] = new Curve(this,
+						this._segments[length - 1], this._segments[0]);
+			}
+			this._changed(41);
+		}
+	}
+}, {
+	beans: true,
+
+	getPathData: function(_matrix, _precision) {
+		var segments = this._segments,
+			length = segments.length,
+			f = new Formatter(_precision),
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY,
+			parts = [];
+
+		function addSegment(segment, skipLine) {
+			segment._transformCoordinates(_matrix, coords);
+			curX = coords[0];
+			curY = coords[1];
+			if (first) {
+				parts.push('M' + f.pair(curX, curY));
+				first = false;
+			} else {
+				inX = coords[2];
+				inY = coords[3];
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					if (!skipLine) {
+						var dx = curX - prevX,
+							dy = curY - prevY;
+						parts.push(
+							  dx === 0 ? 'v' + f.number(dy)
+							: dy === 0 ? 'h' + f.number(dx)
+							: 'l' + f.pair(dx, dy));
+					}
+				} else {
+					parts.push('c' + f.pair(outX - prevX, outY - prevY)
+							 + ' ' + f.pair( inX - prevX,  inY - prevY)
+							 + ' ' + f.pair(curX - prevX, curY - prevY));
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			outX = coords[4];
+			outY = coords[5];
+		}
+
+		if (!length)
+			return '';
+
+		for (var i = 0; i < length; i++)
+			addSegment(segments[i]);
+		if (this._closed && length > 0) {
+			addSegment(segments[0], true);
+			parts.push('z');
+		}
+		return parts.join('');
+	},
+
+	isEmpty: function() {
+		return !this._segments.length;
+	},
+
+	_transformContent: function(matrix) {
+		var segments = this._segments,
+			coords = new Array(6);
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i]._transformCoordinates(matrix, coords, true);
+		return true;
+	},
+
+	_add: function(segs, index) {
+		var segments = this._segments,
+			curves = this._curves,
+			amount = segs.length,
+			append = index == null,
+			index = append ? segments.length : index;
+		for (var i = 0; i < amount; i++) {
+			var segment = segs[i];
+			if (segment._path)
+				segment = segs[i] = segment.clone();
+			segment._path = this;
+			segment._index = index + i;
+			if (segment._selection)
+				this._updateSelection(segment, 0, segment._selection);
+		}
+		if (append) {
+			Base.push(segments, segs);
+		} else {
+			segments.splice.apply(segments, [index, 0].concat(segs));
+			for (var i = index + amount, l = segments.length; i < l; i++)
+				segments[i]._index = i;
+		}
+		if (curves) {
+			var total = this._countCurves(),
+				start = index > 0 && index + amount - 1 === total ? index - 1
+					: index,
+				insert = start,
+				end = Math.min(start + amount, total);
+			if (segs._curves) {
+				curves.splice.apply(curves, [start, 0].concat(segs._curves));
+				insert += segs._curves.length;
+			}
+			for (var i = insert; i < end; i++)
+				curves.splice(i, 0, new Curve(this, null, null));
+			this._adjustCurves(start, end);
+		}
+		this._changed(41);
+		return segs;
+	},
+
+	_adjustCurves: function(start, end) {
+		var segments = this._segments,
+			curves = this._curves,
+			curve;
+		for (var i = start; i < end; i++) {
+			curve = curves[i];
+			curve._path = this;
+			curve._segment1 = segments[i];
+			curve._segment2 = segments[i + 1] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[this._closed && !start ? segments.length - 1
+				: start - 1]) {
+			curve._segment2 = segments[start] || segments[0];
+			curve._changed();
+		}
+		if (curve = curves[end]) {
+			curve._segment1 = segments[end];
+			curve._changed();
+		}
+	},
+
+	_countCurves: function() {
+		var length = this._segments.length;
+		return !this._closed && length > 0 ? length - 1 : length;
+	},
+
+	add: function(segment1 ) {
+		var args = arguments;
+		return args.length > 1 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args))
+			: this._add([ Segment.read(args) ])[0];
+	},
+
+	insert: function(index, segment1 ) {
+		var args = arguments;
+		return args.length > 2 && typeof segment1 !== 'number'
+			? this._add(Segment.readList(args, 1), index)
+			: this._add([ Segment.read(args, 1) ], index)[0];
+	},
+
+	addSegment: function() {
+		return this._add([ Segment.read(arguments) ])[0];
+	},
+
+	insertSegment: function(index ) {
+		return this._add([ Segment.read(arguments, 1) ], index)[0];
+	},
+
+	addSegments: function(segments) {
+		return this._add(Segment.readList(segments));
+	},
+
+	insertSegments: function(index, segments) {
+		return this._add(Segment.readList(segments), index);
+	},
+
+	removeSegment: function(index) {
+		return this.removeSegments(index, index + 1)[0] || null;
+	},
+
+	removeSegments: function(start, end, _includeCurves) {
+		start = start || 0;
+		end = Base.pick(end, this._segments.length);
+		var segments = this._segments,
+			curves = this._curves,
+			count = segments.length,
+			removed = segments.splice(start, end - start),
+			amount = removed.length;
+		if (!amount)
+			return removed;
+		for (var i = 0; i < amount; i++) {
+			var segment = removed[i];
+			if (segment._selection)
+				this._updateSelection(segment, segment._selection, 0);
+			segment._index = segment._path = null;
+		}
+		for (var i = start, l = segments.length; i < l; i++)
+			segments[i]._index = i;
+		if (curves) {
+			var index = start > 0 && end === count + (this._closed ? 1 : 0)
+					? start - 1
+					: start,
+				curves = curves.splice(index, amount);
+			for (var i = curves.length - 1; i >= 0; i--)
+				curves[i]._path = null;
+			if (_includeCurves)
+				removed._curves = curves.slice(1);
+			this._adjustCurves(index, index);
+		}
+		this._changed(41);
+		return removed;
+	},
+
+	clear: '#removeSegments',
+
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
+	},
+
+	clearHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++)
+			segments[i].clearHandles();
+	},
+
+	getLength: function() {
+		if (this._length == null) {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++)
+				length += curves[i].getLength();
+			this._length = length;
+		}
+		return this._length;
+	},
+
+	getArea: function() {
+		var area = this._area;
+		if (area == null) {
+			var segments = this._segments,
+				closed = this._closed;
+			area = 0;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var last = i + 1 === l;
+				area += Curve.getArea(Curve.getValues(
+						segments[i], segments[last ? 0 : i + 1],
+						null, last && !closed));
+			}
+			this._area = area;
+		}
+		return area;
+	},
+
+	isFullySelected: function() {
+		var length = this._segments.length;
+		return this.isSelected() && length > 0 && this._segmentSelection
+				=== length * 7;
+	},
+
+	setFullySelected: function(selected) {
+		if (selected)
+			this._selectSegments(true);
+		this.setSelected(selected);
+	},
+
+	setSelection: function setSelection(selection) {
+		if (!(selection & 1))
+			this._selectSegments(false);
+		setSelection.base.call(this, selection);
+	},
+
+	_selectSegments: function(selected) {
+		var segments = this._segments,
+			length = segments.length,
+			selection = selected ? 7 : 0;
+		this._segmentSelection = selection * length;
+		for (var i = 0; i < length; i++)
+			segments[i]._selection = selection;
+	},
+
+	_updateSelection: function(segment, oldSelection, newSelection) {
+		segment._selection = newSelection;
+		var selection = this._segmentSelection += newSelection - oldSelection;
+		if (selection > 0)
+			this.setSelected(true);
+	},
+
+	divideAt: function(location) {
+		var loc = this.getLocationAt(location),
+			curve;
+		return loc && (curve = loc.getCurve().divideAt(loc.getCurveOffset()))
+				? curve._segment1
+				: null;
+	},
+
+	splitAt: function(location) {
+		var loc = this.getLocationAt(location),
+			index = loc && loc.index,
+			time = loc && loc.time,
+			tMin = 1e-8,
+			tMax = 1 - tMin;
+		if (time > tMax) {
+			index++;
+			time = 0;
+		}
+		var curves = this.getCurves();
+		if (index >= 0 && index < curves.length) {
+			if (time >= tMin) {
+				curves[index++].divideAtTime(time);
+			}
+			var segs = this.removeSegments(index, this._segments.length, true),
+				path;
+			if (this._closed) {
+				this.setClosed(false);
+				path = this;
+			} else {
+				path = new Path(Item.NO_INSERT);
+				path.insertAbove(this);
+				path.copyAttributes(this);
+			}
+			path._add(segs, 0);
+			this.addSegment(segs[0]);
+			return path;
+		}
+		return null;
+	},
+
+	split: function(index, time) {
+		var curve,
+			location = time === undefined ? index
+				: (curve = this.getCurves()[index])
+					&& curve.getLocationAtTime(time);
+		return location != null ? this.splitAt(location) : null;
+	},
+
+	join: function(path, tolerance) {
+		var epsilon = tolerance || 0;
+		if (path && path !== this) {
+			var segments = path._segments,
+				last1 = this.getLastSegment(),
+				last2 = path.getLastSegment();
+			if (!last2)
+				return this;
+			if (last1 && last1._point.isClose(last2._point, epsilon))
+				path.reverse();
+			var first2 = path.getFirstSegment();
+			if (last1 && last1._point.isClose(first2._point, epsilon)) {
+				last1.setHandleOut(first2._handleOut);
+				this._add(segments.slice(1));
+			} else {
+				var first1 = this.getFirstSegment();
+				if (first1 && first1._point.isClose(first2._point, epsilon))
+					path.reverse();
+				last2 = path.getLastSegment();
+				if (first1 && first1._point.isClose(last2._point, epsilon)) {
+					first1.setHandleIn(last2._handleIn);
+					this._add(segments.slice(0, segments.length - 1), 0);
+				} else {
+					this._add(segments.slice());
+				}
+			}
+			if (path._closed)
+				this._add([segments[0]]);
+			path.remove();
+		}
+		var first = this.getFirstSegment(),
+			last = this.getLastSegment();
+		if (first !== last && first._point.isClose(last._point, epsilon)) {
+			first.setHandleIn(last._handleIn);
+			last.remove();
+			this.setClosed(true);
+		}
+		return this;
+	},
+
+	reduce: function(options) {
+		var curves = this.getCurves(),
+			simplify = options && options.simplify,
+			tolerance = simplify ? 1e-7 : 0;
+		for (var i = curves.length - 1; i >= 0; i--) {
+			var curve = curves[i];
+			if (!curve.hasHandles() && (!curve.hasLength(tolerance)
+					|| simplify && curve.isCollinear(curve.getNext())))
+				curve.remove();
+		}
+		return this;
+	},
+
+	reverse: function() {
+		this._segments.reverse();
+		for (var i = 0, l = this._segments.length; i < l; i++) {
+			var segment = this._segments[i];
+			var handleIn = segment._handleIn;
+			segment._handleIn = segment._handleOut;
+			segment._handleOut = handleIn;
+			segment._index = i;
+		}
+		this._curves = null;
+		this._changed(9);
+	},
+
+	flatten: function(flatness) {
+		var flattener = new PathFlattener(this, flatness || 0.25, 256, true),
+			parts = flattener.parts,
+			length = parts.length,
+			segments = [];
+		for (var i = 0; i < length; i++) {
+			segments.push(new Segment(parts[i].curve.slice(0, 2)));
+		}
+		if (!this._closed && length > 0) {
+			segments.push(new Segment(parts[length - 1].curve.slice(6)));
+		}
+		this.setSegments(segments);
+	},
+
+	simplify: function(tolerance) {
+		var segments = new PathFitter(this).fit(tolerance || 2.5);
+		if (segments)
+			this.setSegments(segments);
+		return !!segments;
+	},
+
+	smooth: function(options) {
+		var that = this,
+			opts = options || {},
+			type = opts.type || 'asymmetric',
+			segments = this._segments,
+			length = segments.length,
+			closed = this._closed;
+
+		function getIndex(value, _default) {
+			var index = value && value.index;
+			if (index != null) {
+				var path = value.path;
+				if (path && path !== that)
+					throw new Error(value._class + ' ' + index + ' of ' + path
+							+ ' is not part of ' + that);
+				if (_default && value instanceof Curve)
+					index++;
+			} else {
+				index = typeof value === 'number' ? value : _default;
+			}
+			return Math.min(index < 0 && closed
+					? index % length
+					: index < 0 ? index + length : index, length - 1);
+		}
+
+		var loop = closed && opts.from === undefined && opts.to === undefined,
+			from = getIndex(opts.from, 0),
+			to = getIndex(opts.to, length - 1);
+
+		if (from > to) {
+			if (closed) {
+				from -= length;
+			} else {
+				var tmp = from;
+				from = to;
+				to = tmp;
+			}
+		}
+		if (/^(?:asymmetric|continuous)$/.test(type)) {
+			var asymmetric = type === 'asymmetric',
+				min = Math.min,
+				amount = to - from + 1,
+				n = amount - 1,
+				padding = loop ? min(amount, 4) : 1,
+				paddingLeft = padding,
+				paddingRight = padding,
+				knots = [];
+			if (!closed) {
+				paddingLeft = min(1, from);
+				paddingRight = min(1, length - to - 1);
+			}
+			n += paddingLeft + paddingRight;
+			if (n <= 1)
+				return;
+			for (var i = 0, j = from - paddingLeft; i <= n; i++, j++) {
+				knots[i] = segments[(j < 0 ? j + length : j) % length]._point;
+			}
+
+			var x = knots[0]._x + 2 * knots[1]._x,
+				y = knots[0]._y + 2 * knots[1]._y,
+				f = 2,
+				n_1 = n - 1,
+				rx = [x],
+				ry = [y],
+				rf = [f],
+				px = [],
+				py = [];
+			for (var i = 1; i < n; i++) {
+				var internal = i < n_1,
+					a = internal ? 1 : asymmetric ? 1 : 2,
+					b = internal ? 4 : asymmetric ? 2 : 7,
+					u = internal ? 4 : asymmetric ? 3 : 8,
+					v = internal ? 2 : asymmetric ? 0 : 1,
+					m = a / f;
+				f = rf[i] = b - m;
+				x = rx[i] = u * knots[i]._x + v * knots[i + 1]._x - m * x;
+				y = ry[i] = u * knots[i]._y + v * knots[i + 1]._y - m * y;
+			}
+
+			px[n_1] = rx[n_1] / rf[n_1];
+			py[n_1] = ry[n_1] / rf[n_1];
+			for (var i = n - 2; i >= 0; i--) {
+				px[i] = (rx[i] - px[i + 1]) / rf[i];
+				py[i] = (ry[i] - py[i + 1]) / rf[i];
+			}
+			px[n] = (3 * knots[n]._x - px[n_1]) / 2;
+			py[n] = (3 * knots[n]._y - py[n_1]) / 2;
+
+			for (var i = paddingLeft, max = n - paddingRight, j = from;
+					i <= max; i++, j++) {
+				var segment = segments[j < 0 ? j + length : j],
+					pt = segment._point,
+					hx = px[i] - pt._x,
+					hy = py[i] - pt._y;
+				if (loop || i < max)
+					segment.setHandleOut(hx, hy);
+				if (loop || i > paddingLeft)
+					segment.setHandleIn(-hx, -hy);
+			}
+		} else {
+			for (var i = from; i <= to; i++) {
+				segments[i < 0 ? i + length : i].smooth(opts,
+						!loop && i === from, !loop && i === to);
+			}
+		}
+	},
+
+	toShape: function(insert) {
+		if (!this._closed)
+			return null;
+
+		var segments = this._segments,
+			type,
+			size,
+			radius,
+			topCenter;
+
+		function isCollinear(i, j) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				seg3 = segments[j],
+				seg4 = seg3.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		}
+
+		function isOrthogonal(i) {
+			var seg2 = segments[i],
+				seg1 = seg2.getPrevious(),
+				seg3 = seg2.getNext();
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		}
+
+		function isArc(i) {
+			var seg1 = segments[i],
+				seg2 = seg1.getNext(),
+				handle1 = seg1._handleOut,
+				handle2 = seg2._handleIn,
+				kappa = 0.5522847498307936;
+			if (handle1.isOrthogonal(handle2)) {
+				var pt1 = seg1._point,
+					pt2 = seg2._point,
+					corner = new Line(pt1, handle1, true).intersect(
+							new Line(pt2, handle2, true), true);
+				return corner && Numerical.isZero(handle1.getLength() /
+						corner.subtract(pt1).getLength() - kappa)
+					&& Numerical.isZero(handle2.getLength() /
+						corner.subtract(pt2).getLength() - kappa);
+			}
+			return false;
+		}
+
+		function getDistance(i, j) {
+			return segments[i]._point.getDistance(segments[j]._point);
+		}
+
+		if (!this.hasHandles() && segments.length === 4
+				&& isCollinear(0, 2) && isCollinear(1, 3) && isOrthogonal(1)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(0, 3), getDistance(0, 1));
+			topCenter = segments[1]._point.add(segments[2]._point).divide(2);
+		} else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
+				&& isArc(6) && isCollinear(1, 5) && isCollinear(3, 7)) {
+			type = Shape.Rectangle;
+			size = new Size(getDistance(1, 6), getDistance(0, 3));
+			radius = size.subtract(new Size(getDistance(0, 7),
+					getDistance(1, 2))).divide(2);
+			topCenter = segments[3]._point.add(segments[4]._point).divide(2);
+		} else if (segments.length === 4
+				&& isArc(0) && isArc(1) && isArc(2) && isArc(3)) {
+			if (Numerical.isZero(getDistance(0, 2) - getDistance(1, 3))) {
+				type = Shape.Circle;
+				radius = getDistance(0, 2) / 2;
+			} else {
+				type = Shape.Ellipse;
+				radius = new Size(getDistance(2, 0) / 2, getDistance(3, 1) / 2);
+			}
+			topCenter = segments[1]._point;
+		}
+
+		if (type) {
+			var center = this.getPosition(true),
+				shape = new type({
+					center: center,
+					size: size,
+					radius: radius,
+					insert: false
+				});
+			shape.copyAttributes(this, true);
+			shape._matrix.prepend(this._matrix);
+			shape.rotate(topCenter.subtract(center).getAngle() + 90);
+			if (insert === undefined || insert)
+				shape.insertAbove(this);
+			return shape;
+		}
+		return null;
+	},
+
+	toPath: '#clone',
+
+	compare: function compare(path) {
+		if (!path || path instanceof CompoundPath)
+			return compare.base.call(this, path);
+		var curves1 = this.getCurves(),
+			curves2 = path.getCurves(),
+			length1 = curves1.length,
+			length2 = curves2.length;
+		if (!length1 || !length2) {
+			return length1 == length2;
+		}
+		var v1 = curves1[0].getValues(),
+			values2 = [],
+			pos1 = 0, pos2,
+			end1 = 0, end2;
+		for (var i = 0; i < length2; i++) {
+			var v2 = curves2[i].getValues();
+			values2.push(v2);
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				pos2 = !i && overlaps[0][0] > 0 ? length2 - 1 : i;
+				end2 = overlaps[0][1];
+				break;
+			}
+		}
+		var abs = Math.abs,
+			epsilon = 1e-8,
+			v2 = values2[pos2],
+			start2;
+		while (v1 && v2) {
+			var overlaps = Curve.getOverlaps(v1, v2);
+			if (overlaps) {
+				var t1 = overlaps[0][0];
+				if (abs(t1 - end1) < epsilon) {
+					end1 = overlaps[1][0];
+					if (end1 === 1) {
+						v1 = ++pos1 < length1 ? curves1[pos1].getValues() : null;
+						end1 = 0;
+					}
+					var t2 = overlaps[0][1];
+					if (abs(t2 - end2) < epsilon) {
+						if (!start2)
+							start2 = [pos2, t2];
+						end2 = overlaps[1][1];
+						if (end2 === 1) {
+							if (++pos2 >= length2)
+								pos2 = 0;
+							v2 = values2[pos2] || curves2[pos2].getValues();
+							end2 = 0;
+						}
+						if (!v1) {
+							return start2[0] === pos2 && start2[1] === end2;
+						}
+						continue;
+					}
+				}
+			}
+			break;
+		}
+		return false;
+	},
+
+	_hitTestSelf: function(point, options, viewMatrix, strokeMatrix) {
+		var that = this,
+			style = this.getStyle(),
+			segments = this._segments,
+			numSegments = segments.length,
+			closed = this._closed,
+			tolerancePadding = options._tolerancePadding,
+			strokePadding = tolerancePadding,
+			join, cap, miterLimit,
+			area, loc, res,
+			hitStroke = options.stroke && style.hasStroke(),
+			hitFill = options.fill && style.hasFill(),
+			hitCurves = options.curves,
+			strokeRadius = hitStroke
+					? style.getStrokeWidth() / 2
+					: hitFill && options.tolerance > 0 || hitCurves
+						? 0 : null;
+		if (strokeRadius !== null) {
+			if (strokeRadius > 0) {
+				join = style.getStrokeJoin();
+				cap = style.getStrokeCap();
+				miterLimit = style.getMiterLimit();
+				strokePadding = strokePadding.add(
+					Path._getStrokePadding(strokeRadius, strokeMatrix));
+			} else {
+				join = cap = 'round';
+			}
+		}
+
+		function isCloseEnough(pt, padding) {
+			return point.subtract(pt).divide(padding).length <= 1;
+		}
+
+		function checkSegmentPoint(seg, pt, name) {
+			if (!options.selected || pt.isSelected()) {
+				var anchor = seg._point;
+				if (pt !== anchor)
+					pt = pt.add(anchor);
+				if (isCloseEnough(pt, strokePadding)) {
+					return new HitResult(name, that, {
+						segment: seg,
+						point: pt
+					});
+				}
+			}
+		}
+
+		function checkSegmentPoints(seg, ends) {
+			return (ends || options.segments)
+				&& checkSegmentPoint(seg, seg._point, 'segment')
+				|| (!ends && options.handles) && (
+					checkSegmentPoint(seg, seg._handleIn, 'handle-in') ||
+					checkSegmentPoint(seg, seg._handleOut, 'handle-out'));
+		}
+
+		function addToArea(point) {
+			area.add(point);
+		}
+
+		function checkSegmentStroke(segment) {
+			var isJoin = closed || segment._index > 0
+					&& segment._index < numSegments - 1;
+			if ((isJoin ? join : cap) === 'round') {
+				return isCloseEnough(segment._point, strokePadding);
+			} else {
+				area = new Path({ internal: true, closed: true });
+				if (isJoin) {
+					if (!segment.isSmooth()) {
+						Path._addBevelJoin(segment, join, strokeRadius,
+							   miterLimit, null, strokeMatrix, addToArea, true);
+					}
+				} else if (cap === 'square') {
+					Path._addSquareCap(segment, cap, strokeRadius, null,
+							strokeMatrix, addToArea, true);
+				}
+				if (!area.isEmpty()) {
+					var loc;
+					return area.contains(point)
+						|| (loc = area.getNearestLocation(point))
+							&& isCloseEnough(loc.getPoint(), tolerancePadding);
+				}
+			}
+		}
+
+		if (options.ends && !options.segments && !closed) {
+			if (res = checkSegmentPoints(segments[0], true)
+					|| checkSegmentPoints(segments[numSegments - 1], true))
+				return res;
+		} else if (options.segments || options.handles) {
+			for (var i = 0; i < numSegments; i++)
+				if (res = checkSegmentPoints(segments[i]))
+					return res;
+		}
+		if (strokeRadius !== null) {
+			loc = this.getNearestLocation(point);
+			if (loc) {
+				var time = loc.getTime();
+				if (time === 0 || time === 1 && numSegments > 1) {
+					if (!checkSegmentStroke(loc.getSegment()))
+						loc = null;
+				} else if (!isCloseEnough(loc.getPoint(), strokePadding)) {
+					loc = null;
+				}
+			}
+			if (!loc && join === 'miter' && numSegments > 1) {
+				for (var i = 0; i < numSegments; i++) {
+					var segment = segments[i];
+					if (point.getDistance(segment._point)
+							<= miterLimit * strokeRadius
+							&& checkSegmentStroke(segment)) {
+						loc = segment.getLocation();
+						break;
+					}
+				}
+			}
+		}
+		return !loc && hitFill && this._contains(point)
+				|| loc && !hitStroke && !hitCurves
+					? new HitResult('fill', this)
+					: loc
+						? new HitResult(hitStroke ? 'stroke' : 'curve', this, {
+							location: loc,
+							point: loc.getPoint()
+						})
+						: null;
+	}
+
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var loc = this.getLocationAt(offset);
+			return loc && loc[name]();
+		};
+	},
+{
+	beans: false,
+
+	getLocationOf: function() {
+		var point = Point.read(arguments),
+			curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var loc = curves[i].getLocationOf(point);
+			if (loc)
+				return loc;
+		}
+		return null;
+	},
+
+	getOffsetOf: function() {
+		var loc = this.getLocationOf.apply(this, arguments);
+		return loc ? loc.getOffset() : null;
+	},
+
+	getLocationAt: function(offset) {
+		if (typeof offset === 'number') {
+			var curves = this.getCurves(),
+				length = 0;
+			for (var i = 0, l = curves.length; i < l; i++) {
+				var start = length,
+					curve = curves[i];
+				length += curve.getLength();
+				if (length > offset) {
+					return curve.getLocationAt(offset - start);
+				}
+			}
+			if (curves.length > 0 && offset <= this.getLength()) {
+				return new CurveLocation(curves[curves.length - 1], 1);
+			}
+		} else if (offset && offset.getPath && offset.getPath() === this) {
+			return offset;
+		}
+		return null;
+	},
+
+	getOffsetsWithTangent: function() {
+		var tangent = Point.read(arguments);
+		if (tangent.isZero()) {
+			return [];
+		}
+
+		var offsets = [];
+		var curveStart = 0;
+		var curves = this.getCurves();
+		for (var i = 0, l = curves.length; i < l; i++) {
+			var curve = curves[i];
+			var curveTimes = curve.getTimesWithTangent(tangent);
+			for (var j = 0, m = curveTimes.length; j < m; j++) {
+				var offset = curveStart + curve.getOffsetAtTime(curveTimes[j]);
+				if (offsets.indexOf(offset) < 0) {
+					offsets.push(offset);
+				}
+			}
+			curveStart += curve.length;
+		}
+		return offsets;
+	}
+}),
+new function() {
+
+	function drawHandles(ctx, segments, matrix, size) {
+		if (size <= 0) return;
+
+		var half = size / 2,
+			miniSize = size - 2,
+			miniHalf = half - 1,
+			coords = new Array(6),
+			pX, pY;
+
+		function drawHandle(index) {
+			var hX = coords[index],
+				hY = coords[index + 1];
+			if (pX != hX || pY != hY) {
+				ctx.beginPath();
+				ctx.moveTo(pX, pY);
+				ctx.lineTo(hX, hY);
+				ctx.stroke();
+				ctx.beginPath();
+				ctx.arc(hX, hY, half, 0, Math.PI * 2, true);
+				ctx.fill();
+			}
+		}
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i],
+				selection = segment._selection;
+			segment._transformCoordinates(matrix, coords);
+			pX = coords[0];
+			pY = coords[1];
+			if (selection & 2)
+				drawHandle(2);
+			if (selection & 4)
+				drawHandle(4);
+			ctx.fillRect(pX - half, pY - half, size, size);
+			if (miniSize > 0 && !(selection & 1)) {
+				var fillStyle = ctx.fillStyle;
+				ctx.fillStyle = '#ffffff';
+				ctx.fillRect(pX - miniHalf, pY - miniHalf, miniSize, miniSize);
+				ctx.fillStyle = fillStyle;
+			}
+		}
+	}
+
+	function drawSegments(ctx, path, matrix) {
+		var segments = path._segments,
+			length = segments.length,
+			coords = new Array(6),
+			first = true,
+			curX, curY,
+			prevX, prevY,
+			inX, inY,
+			outX, outY;
+
+		function drawSegment(segment) {
+			if (matrix) {
+				segment._transformCoordinates(matrix, coords);
+				curX = coords[0];
+				curY = coords[1];
+			} else {
+				var point = segment._point;
+				curX = point._x;
+				curY = point._y;
+			}
+			if (first) {
+				ctx.moveTo(curX, curY);
+				first = false;
+			} else {
+				if (matrix) {
+					inX = coords[2];
+					inY = coords[3];
+				} else {
+					var handle = segment._handleIn;
+					inX = curX + handle._x;
+					inY = curY + handle._y;
+				}
+				if (inX === curX && inY === curY
+						&& outX === prevX && outY === prevY) {
+					ctx.lineTo(curX, curY);
+				} else {
+					ctx.bezierCurveTo(outX, outY, inX, inY, curX, curY);
+				}
+			}
+			prevX = curX;
+			prevY = curY;
+			if (matrix) {
+				outX = coords[4];
+				outY = coords[5];
+			} else {
+				var handle = segment._handleOut;
+				outX = prevX + handle._x;
+				outY = prevY + handle._y;
+			}
+		}
+
+		for (var i = 0; i < length; i++)
+			drawSegment(segments[i]);
+		if (path._closed && length > 0)
+			drawSegment(segments[0]);
+	}
+
+	return {
+		_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+			var dontStart = param.dontStart,
+				dontPaint = param.dontFinish || param.clip,
+				style = this.getStyle(),
+				hasFill = style.hasFill(),
+				hasStroke = style.hasStroke(),
+				dashArray = style.getDashArray(),
+				dashLength = !paper.support.nativeDash && hasStroke
+						&& dashArray && dashArray.length;
+
+			if (!dontStart)
+				ctx.beginPath();
+
+			if (hasFill || hasStroke && !dashLength || dontPaint) {
+				drawSegments(ctx, this, strokeMatrix);
+				if (this._closed)
+					ctx.closePath();
+			}
+
+			function getOffset(i) {
+				return dashArray[((i % dashLength) + dashLength) % dashLength];
+			}
+
+			if (!dontPaint && (hasFill || hasStroke)) {
+				this._setStyles(ctx, param, viewMatrix);
+				if (hasFill) {
+					ctx.fill(style.getFillRule());
+					ctx.shadowColor = 'rgba(0,0,0,0)';
+				}
+				if (hasStroke) {
+					if (dashLength) {
+						if (!dontStart)
+							ctx.beginPath();
+						var flattener = new PathFlattener(this, 0.25, 32, false,
+								strokeMatrix),
+							length = flattener.length,
+							from = -style.getDashOffset(), to,
+							i = 0;
+						from = from % length;
+						while (from > 0) {
+							from -= getOffset(i--) + getOffset(i--);
+						}
+						while (from < length) {
+							to = from + getOffset(i++);
+							if (from > 0 || to > 0)
+								flattener.drawPart(ctx,
+										Math.max(from, 0), Math.max(to, 0));
+							from = to + getOffset(i++);
+						}
+					}
+					ctx.stroke();
+				}
+			}
+		},
+
+		_drawSelected: function(ctx, matrix) {
+			ctx.beginPath();
+			drawSegments(ctx, this, matrix);
+			ctx.stroke();
+			drawHandles(ctx, this._segments, matrix, paper.settings.handleSize);
+		}
+	};
+},
+new function() {
+	function getCurrentSegment(that) {
+		var segments = that._segments;
+		if (!segments.length)
+			throw new Error('Use a moveTo() command first');
+		return segments[segments.length - 1];
+	}
+
+	return {
+		moveTo: function() {
+			var segments = this._segments;
+			if (segments.length === 1)
+				this.removeSegment(0);
+			if (!segments.length)
+				this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		moveBy: function() {
+			throw new Error('moveBy() is unsupported on Path items.');
+		},
+
+		lineTo: function() {
+			this._add([ new Segment(Point.read(arguments)) ]);
+		},
+
+		cubicCurveTo: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this);
+			current.setHandleOut(handle1.subtract(current._point));
+			this._add([ new Segment(to, handle2.subtract(to)) ]);
+		},
+
+		quadraticCurveTo: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(
+				handle.add(current.subtract(handle).multiply(1 / 3)),
+				handle.add(to.subtract(handle).multiply(1 / 3)),
+				to
+			);
+		},
+
+		curveTo: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				t = Base.pick(Base.read(args), 0.5),
+				t1 = 1 - t,
+				current = getCurrentSegment(this)._point,
+				handle = through.subtract(current.multiply(t1 * t1))
+					.subtract(to.multiply(t * t)).divide(2 * t * t1);
+			if (handle.isNaN())
+				throw new Error(
+					'Cannot put a curve through points with parameter = ' + t);
+			this.quadraticCurveTo(handle, to);
+		},
+
+		arcTo: function() {
+			var args = arguments,
+				abs = Math.abs,
+				sqrt = Math.sqrt,
+				current = getCurrentSegment(this),
+				from = current._point,
+				to = Point.read(args),
+				through,
+				peek = Base.peek(args),
+				clockwise = Base.pick(peek, true),
+				center, extent, vector, matrix;
+			if (typeof clockwise === 'boolean') {
+				var middle = from.add(to).divide(2),
+				through = middle.add(middle.subtract(from).rotate(
+						clockwise ? -90 : 90));
+			} else if (Base.remain(args) <= 2) {
+				through = to;
+				to = Point.read(args);
+			} else if (!from.equals(to)) {
+				var radius = Size.read(args),
+					isZero = Numerical.isZero;
+				if (isZero(radius.width) || isZero(radius.height))
+					return this.lineTo(to);
+				var rotation = Base.read(args),
+					clockwise = !!Base.read(args),
+					large = !!Base.read(args),
+					middle = from.add(to).divide(2),
+					pt = from.subtract(middle).rotate(-rotation),
+					x = pt.x,
+					y = pt.y,
+					rx = abs(radius.width),
+					ry = abs(radius.height),
+					rxSq = rx * rx,
+					rySq = ry * ry,
+					xSq = x * x,
+					ySq = y * y;
+				var factor = sqrt(xSq / rxSq + ySq / rySq);
+				if (factor > 1) {
+					rx *= factor;
+					ry *= factor;
+					rxSq = rx * rx;
+					rySq = ry * ry;
+				}
+				factor = (rxSq * rySq - rxSq * ySq - rySq * xSq) /
+						(rxSq * ySq + rySq * xSq);
+				if (abs(factor) < 1e-12)
+					factor = 0;
+				if (factor < 0)
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				center = new Point(rx * y / ry, -ry * x / rx)
+						.multiply((large === clockwise ? -1 : 1) * sqrt(factor))
+						.rotate(rotation).add(middle);
+				matrix = new Matrix().translate(center).rotate(rotation)
+						.scale(rx, ry);
+				vector = matrix._inverseTransform(from);
+				extent = vector.getDirectedAngle(matrix._inverseTransform(to));
+				if (!clockwise && extent > 0)
+					extent -= 360;
+				else if (clockwise && extent < 0)
+					extent += 360;
+			}
+			if (through) {
+				var l1 = new Line(from.add(through).divide(2),
+							through.subtract(from).rotate(90), true),
+					l2 = new Line(through.add(to).divide(2),
+							to.subtract(through).rotate(90), true),
+					line = new Line(from, to),
+					throughSide = line.getSide(through);
+				center = l1.intersect(l2, true);
+				if (!center) {
+					if (!throughSide)
+						return this.lineTo(to);
+					throw new Error(
+							'Cannot create an arc with the given arguments');
+				}
+				vector = from.subtract(center);
+				extent = vector.getDirectedAngle(to.subtract(center));
+				var centerSide = line.getSide(center, true);
+				if (centerSide === 0) {
+					extent = throughSide * abs(extent);
+				} else if (throughSide === centerSide) {
+					extent += extent < 0 ? 360 : -360;
+				}
+			}
+			if (extent) {
+				var epsilon = 1e-7,
+					ext = abs(extent),
+					count = ext >= 360 ? 4 : Math.ceil((ext - epsilon) / 90),
+					inc = extent / count,
+					half = inc * Math.PI / 360,
+					z = 4 / 3 * Math.sin(half) / (1 + Math.cos(half)),
+					segments = [];
+				for (var i = 0; i <= count; i++) {
+					var pt = to,
+						out = null;
+					if (i < count) {
+						out = vector.rotate(90).multiply(z);
+						if (matrix) {
+							pt = matrix._transformPoint(vector);
+							out = matrix._transformPoint(vector.add(out))
+									.subtract(pt);
+						} else {
+							pt = center.add(vector);
+						}
+					}
+					if (!i) {
+						current.setHandleOut(out);
+					} else {
+						var _in = vector.rotate(-90).multiply(z);
+						if (matrix) {
+							_in = matrix._transformPoint(vector.add(_in))
+									.subtract(pt);
+						}
+						segments.push(new Segment(pt, _in, out));
+					}
+					vector = vector.rotate(inc);
+				}
+				this._add(segments);
+			}
+		},
+
+		lineBy: function() {
+			var to = Point.read(arguments),
+				current = getCurrentSegment(this)._point;
+			this.lineTo(current.add(to));
+		},
+
+		curveBy: function() {
+			var args = arguments,
+				through = Point.read(args),
+				to = Point.read(args),
+				parameter = Base.read(args),
+				current = getCurrentSegment(this)._point;
+			this.curveTo(current.add(through), current.add(to), parameter);
+		},
+
+		cubicCurveBy: function() {
+			var args = arguments,
+				handle1 = Point.read(args),
+				handle2 = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.cubicCurveTo(current.add(handle1), current.add(handle2),
+					current.add(to));
+		},
+
+		quadraticCurveBy: function() {
+			var args = arguments,
+				handle = Point.read(args),
+				to = Point.read(args),
+				current = getCurrentSegment(this)._point;
+			this.quadraticCurveTo(current.add(handle), current.add(to));
+		},
+
+		arcBy: function() {
+			var args = arguments,
+				current = getCurrentSegment(this)._point,
+				point = current.add(Point.read(args)),
+				clockwise = Base.pick(Base.peek(args), true);
+			if (typeof clockwise === 'boolean') {
+				this.arcTo(point, clockwise);
+			} else {
+				this.arcTo(point, current.add(Point.read(args)));
+			}
+		},
+
+		closePath: function(tolerance) {
+			this.setClosed(true);
+			this.join(this, tolerance);
+		}
+	};
+}, {
+
+	_getBounds: function(matrix, options) {
+		var method = options.handle
+				? 'getHandleBounds'
+				: options.stroke
+				? 'getStrokeBounds'
+				: 'getBounds';
+		return Path[method](this._segments, this._closed, this, matrix, options);
+	},
+
+statics: {
+	getBounds: function(segments, closed, path, matrix, options, strokePadding) {
+		var first = segments[0];
+		if (!first)
+			return new Rectangle();
+		var coords = new Array(6),
+			prevCoords = first._transformCoordinates(matrix, new Array(6)),
+			min = prevCoords.slice(0, 2),
+			max = min.slice(),
+			roots = new Array(2);
+
+		function processSegment(segment) {
+			segment._transformCoordinates(matrix, coords);
+			for (var i = 0; i < 2; i++) {
+				Curve._addBounds(
+					prevCoords[i],
+					prevCoords[i + 4],
+					coords[i + 2],
+					coords[i],
+					i, strokePadding ? strokePadding[i] : 0, min, max, roots);
+			}
+			var tmp = prevCoords;
+			prevCoords = coords;
+			coords = tmp;
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++)
+			processSegment(segments[i]);
+		if (closed)
+			processSegment(first);
+		return new Rectangle(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+	},
+
+	getStrokeBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = style.hasStroke(),
+			strokeWidth = style.getStrokeWidth(),
+			strokeMatrix = stroke && path._getStrokeMatrix(matrix, options),
+			strokePadding = stroke && Path._getStrokePadding(strokeWidth,
+				strokeMatrix),
+			bounds = Path.getBounds(segments, closed, path, matrix, options,
+				strokePadding);
+		if (!stroke)
+			return bounds;
+		var strokeRadius = strokeWidth / 2,
+			join = style.getStrokeJoin(),
+			cap = style.getStrokeCap(),
+			miterLimit = style.getMiterLimit(),
+			joinBounds = new Rectangle(new Size(strokePadding));
+
+		function addPoint(point) {
+			bounds = bounds.include(point);
+		}
+
+		function addRound(segment) {
+			bounds = bounds.unite(
+					joinBounds.setCenter(segment._point.transform(matrix)));
+		}
+
+		function addJoin(segment, join) {
+			if (join === 'round' || segment.isSmooth()) {
+				addRound(segment);
+			} else {
+				Path._addBevelJoin(segment, join, strokeRadius, miterLimit,
+						matrix, strokeMatrix, addPoint);
+			}
+		}
+
+		function addCap(segment, cap) {
+			if (cap === 'round') {
+				addRound(segment);
+			} else {
+				Path._addSquareCap(segment, cap, strokeRadius, matrix,
+						strokeMatrix, addPoint);
+			}
+		}
+
+		var length = segments.length - (closed ? 0 : 1);
+		if (length > 0) {
+			for (var i = 1; i < length; i++) {
+				addJoin(segments[i], join);
+			}
+			if (closed) {
+				addJoin(segments[0], join);
+			} else {
+				addCap(segments[0], cap);
+				addCap(segments[segments.length - 1], cap);
+			}
+		}
+		return bounds;
+	},
+
+	_getStrokePadding: function(radius, matrix) {
+		if (!matrix)
+			return [radius, radius];
+		var hor = new Point(radius, 0).transform(matrix),
+			ver = new Point(0, radius).transform(matrix),
+			phi = hor.getAngleInRadians(),
+			a = hor.getLength(),
+			b = ver.getLength();
+		var sin = Math.sin(phi),
+			cos = Math.cos(phi),
+			tan = Math.tan(phi),
+			tx = Math.atan2(b * tan, a),
+			ty = Math.atan2(b, tan * a);
+		return [Math.abs(a * Math.cos(tx) * cos + b * Math.sin(tx) * sin),
+				Math.abs(b * Math.sin(ty) * cos + a * Math.cos(ty) * sin)];
+	},
+
+	_addBevelJoin: function(segment, join, radius, miterLimit, matrix,
+			strokeMatrix, addPoint, isArea) {
+		var curve2 = segment.getCurve(),
+			curve1 = curve2.getPrevious(),
+			point = curve2.getPoint1().transform(matrix),
+			normal1 = curve1.getNormalAtTime(1).multiply(radius)
+				.transform(strokeMatrix),
+			normal2 = curve2.getNormalAtTime(0).multiply(radius)
+				.transform(strokeMatrix),
+				angle = normal1.getDirectedAngle(normal2);
+		if (angle < 0 || angle >= 180) {
+			normal1 = normal1.negate();
+			normal2 = normal2.negate();
+		}
+		if (isArea)
+			addPoint(point);
+		addPoint(point.add(normal1));
+		if (join === 'miter') {
+			var corner = new Line(point.add(normal1),
+					new Point(-normal1.y, normal1.x), true
+				).intersect(new Line(point.add(normal2),
+					new Point(-normal2.y, normal2.x), true
+				), true);
+			if (corner && point.getDistance(corner) <= miterLimit * radius) {
+				addPoint(corner);
+			}
+		}
+		addPoint(point.add(normal2));
+	},
+
+	_addSquareCap: function(segment, cap, radius, matrix, strokeMatrix,
+			addPoint, isArea) {
+		var point = segment._point.transform(matrix),
+			loc = segment.getLocation(),
+			normal = loc.getNormal()
+					.multiply(loc.getTime() === 0 ? radius : -radius)
+					.transform(strokeMatrix);
+		if (cap === 'square') {
+			if (isArea) {
+				addPoint(point.subtract(normal));
+				addPoint(point.add(normal));
+			}
+			point = point.add(normal.rotate(-90));
+		}
+		addPoint(point.add(normal));
+		addPoint(point.subtract(normal));
+	},
+
+	getHandleBounds: function(segments, closed, path, matrix, options) {
+		var style = path.getStyle(),
+			stroke = options.stroke && style.hasStroke(),
+			strokePadding,
+			joinPadding;
+		if (stroke) {
+			var strokeMatrix = path._getStrokeMatrix(matrix, options),
+				strokeRadius = style.getStrokeWidth() / 2,
+				joinRadius = strokeRadius;
+			if (style.getStrokeJoin() === 'miter')
+				joinRadius = strokeRadius * style.getMiterLimit();
+			if (style.getStrokeCap() === 'square')
+				joinRadius = Math.max(joinRadius, strokeRadius * Math.SQRT2);
+			strokePadding = Path._getStrokePadding(strokeRadius, strokeMatrix);
+			joinPadding = Path._getStrokePadding(joinRadius, strokeMatrix);
+		}
+		var coords = new Array(6),
+			x1 = Infinity,
+			x2 = -x1,
+			y1 = x1,
+			y2 = x2;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var segment = segments[i];
+			segment._transformCoordinates(matrix, coords);
+			for (var j = 0; j < 6; j += 2) {
+				var padding = !j ? joinPadding : strokePadding,
+					paddingX = padding ? padding[0] : 0,
+					paddingY = padding ? padding[1] : 0,
+					x = coords[j],
+					y = coords[j + 1],
+					xn = x - paddingX,
+					xx = x + paddingX,
+					yn = y - paddingY,
+					yx = y + paddingY;
+				if (xn < x1) x1 = xn;
+				if (xx > x2) x2 = xx;
+				if (yn < y1) y1 = yn;
+				if (yx > y2) y2 = yx;
+			}
+		}
+		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
+	}
+}});
+
+Path.inject({ statics: new function() {
+
+	var kappa = 0.5522847498307936,
+		ellipseSegments = [
+			new Segment([-1, 0], [0, kappa ], [0, -kappa]),
+			new Segment([0, -1], [-kappa, 0], [kappa, 0 ]),
+			new Segment([1, 0], [0, -kappa], [0, kappa ]),
+			new Segment([0, 1], [kappa, 0 ], [-kappa, 0])
+		];
+
+	function createPath(segments, closed, args) {
+		var props = Base.getNamed(args),
+			path = new Path(props && props.insert == false && Item.NO_INSERT);
+		path._add(segments);
+		path._closed = closed;
+		return path.set(props, { insert: true });
+	}
+
+	function createEllipse(center, radius, args) {
+		var segments = new Array(4);
+		for (var i = 0; i < 4; i++) {
+			var segment = ellipseSegments[i];
+			segments[i] = new Segment(
+				segment._point.multiply(radius).add(center),
+				segment._handleIn.multiply(radius),
+				segment._handleOut.multiply(radius)
+			);
+		}
+		return createPath(segments, true, args);
+	}
+
+	return {
+		Line: function() {
+			var args = arguments;
+			return createPath([
+				new Segment(Point.readNamed(args, 'from')),
+				new Segment(Point.readNamed(args, 'to'))
+			], false, args);
+		},
+
+		Circle: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				radius = Base.readNamed(args, 'radius');
+			return createEllipse(center, new Size(radius), args);
+		},
+
+		Rectangle: function() {
+			var args = arguments,
+				rect = Rectangle.readNamed(args, 'rectangle'),
+				radius = Size.readNamed(args, 'radius', 0,
+						{ readNull: true }),
+				bl = rect.getBottomLeft(true),
+				tl = rect.getTopLeft(true),
+				tr = rect.getTopRight(true),
+				br = rect.getBottomRight(true),
+				segments;
+			if (!radius || radius.isZero()) {
+				segments = [
+					new Segment(bl),
+					new Segment(tl),
+					new Segment(tr),
+					new Segment(br)
+				];
+			} else {
+				radius = Size.min(radius, rect.getSize(true).divide(2));
+				var rx = radius.width,
+					ry = radius.height,
+					hx = rx * kappa,
+					hy = ry * kappa;
+				segments = [
+					new Segment(bl.add(rx, 0), null, [-hx, 0]),
+					new Segment(bl.subtract(0, ry), [0, hy]),
+					new Segment(tl.add(0, ry), null, [0, -hy]),
+					new Segment(tl.add(rx, 0), [-hx, 0], null),
+					new Segment(tr.subtract(rx, 0), null, [hx, 0]),
+					new Segment(tr.add(0, ry), [0, -hy], null),
+					new Segment(br.subtract(0, ry), null, [0, hy]),
+					new Segment(br.subtract(rx, 0), [hx, 0])
+				];
+			}
+			return createPath(segments, true, args);
+		},
+
+		RoundRectangle: '#Rectangle',
+
+		Ellipse: function() {
+			var args = arguments,
+				ellipse = Shape._readEllipse(args);
+			return createEllipse(ellipse.center, ellipse.radius, args);
+		},
+
+		Oval: '#Ellipse',
+
+		Arc: function() {
+			var args = arguments,
+				from = Point.readNamed(args, 'from'),
+				through = Point.readNamed(args, 'through'),
+				to = Point.readNamed(args, 'to'),
+				props = Base.getNamed(args),
+				path = new Path(props && props.insert == false
+						&& Item.NO_INSERT);
+			path.moveTo(from);
+			path.arcTo(through, to);
+			return path.set(props);
+		},
+
+		RegularPolygon: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				sides = Base.readNamed(args, 'sides'),
+				radius = Base.readNamed(args, 'radius'),
+				step = 360 / sides,
+				three = sides % 3 === 0,
+				vector = new Point(0, three ? -radius : radius),
+				offset = three ? -1 : 0.5,
+				segments = new Array(sides);
+			for (var i = 0; i < sides; i++)
+				segments[i] = new Segment(center.add(
+					vector.rotate((i + offset) * step)));
+			return createPath(segments, true, args);
+		},
+
+		Star: function() {
+			var args = arguments,
+				center = Point.readNamed(args, 'center'),
+				points = Base.readNamed(args, 'points') * 2,
+				radius1 = Base.readNamed(args, 'radius1'),
+				radius2 = Base.readNamed(args, 'radius2'),
+				step = 360 / points,
+				vector = new Point(0, -1),
+				segments = new Array(points);
+			for (var i = 0; i < points; i++)
+				segments[i] = new Segment(center.add(vector.rotate(step * i)
+						.multiply(i % 2 ? radius2 : radius1)));
+			return createPath(segments, true, args);
+		}
+	};
+}});
+
+var CompoundPath = PathItem.extend({
+	_class: 'CompoundPath',
+	_serializeFields: {
+		children: []
+	},
+	beans: true,
+
+	initialize: function CompoundPath(arg) {
+		this._children = [];
+		this._namedChildren = {};
+		if (!this._initialize(arg)) {
+			if (typeof arg === 'string') {
+				this.setPathData(arg);
+			} else {
+				this.addChildren(Array.isArray(arg) ? arg : arguments);
+			}
+		}
+	},
+
+	insertChildren: function insertChildren(index, items) {
+		var list = items,
+			first = list[0];
+		if (first && typeof first[0] === 'number')
+			list = [list];
+		for (var i = items.length - 1; i >= 0; i--) {
+			var item = list[i];
+			if (list === items && !(item instanceof Path))
+				list = Base.slice(list);
+			if (Array.isArray(item)) {
+				list[i] = new Path({ segments: item, insert: false });
+			} else if (item instanceof CompoundPath) {
+				list.splice.apply(list, [i, 1].concat(item.removeChildren()));
+				item.remove();
+			}
+		}
+		return insertChildren.base.call(this, index, list);
+	},
+
+	reduce: function reduce(options) {
+		var children = this._children;
+		for (var i = children.length - 1; i >= 0; i--) {
+			var path = children[i].reduce(options);
+			if (path.isEmpty())
+				path.remove();
+		}
+		if (!children.length) {
+			var path = new Path(Item.NO_INSERT);
+			path.copyAttributes(this);
+			path.insertAbove(this);
+			this.remove();
+			return path;
+		}
+		return reduce.base.call(this);
+	},
+
+	isClosed: function() {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			if (!children[i]._closed)
+				return false;
+		}
+		return true;
+	},
+
+	setClosed: function(closed) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			children[i].setClosed(closed);
+		}
+	},
+
+	getFirstSegment: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstSegment();
+	},
+
+	getLastSegment: function() {
+		var last = this.getLastChild();
+		return last && last.getLastSegment();
+	},
+
+	getCurves: function() {
+		var children = this._children,
+			curves = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			Base.push(curves, children[i].getCurves());
+		}
+		return curves;
+	},
+
+	getFirstCurve: function() {
+		var first = this.getFirstChild();
+		return first && first.getFirstCurve();
+	},
+
+	getLastCurve: function() {
+		var last = this.getLastChild();
+		return last && last.getLastCurve();
+	},
+
+	getArea: function() {
+		var children = this._children,
+			area = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			area += children[i].getArea();
+		return area;
+	},
+
+	getLength: function() {
+		var children = this._children,
+			length = 0;
+		for (var i = 0, l = children.length; i < l; i++)
+			length += children[i].getLength();
+		return length;
+	},
+
+	getPathData: function(_matrix, _precision) {
+		var children = this._children,
+			paths = [];
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			paths.push(child.getPathData(_matrix && !mx.isIdentity()
+					? _matrix.appended(mx) : _matrix, _precision));
+		}
+		return paths.join('');
+	},
+
+	_hitTestChildren: function _hitTestChildren(point, options, viewMatrix) {
+		return _hitTestChildren.base.call(this, point,
+				options.class === Path || options.type === 'path' ? options
+					: Base.set({}, options, { fill: false }),
+				viewMatrix);
+	},
+
+	_draw: function(ctx, param, viewMatrix, strokeMatrix) {
+		var children = this._children;
+		if (!children.length)
+			return;
+
+		param = param.extend({ dontStart: true, dontFinish: true });
+		ctx.beginPath();
+		for (var i = 0, l = children.length; i < l; i++)
+			children[i].draw(ctx, param, strokeMatrix);
+
+		if (!param.clip) {
+			this._setStyles(ctx, param, viewMatrix);
+			var style = this._style;
+			if (style.hasFill()) {
+				ctx.fill(style.getFillRule());
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (style.hasStroke())
+				ctx.stroke();
+		}
+	},
+
+	_drawSelected: function(ctx, matrix, selectionItems) {
+		var children = this._children;
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i],
+				mx = child._matrix;
+			if (!selectionItems[child._id]) {
+				child._drawSelected(ctx, mx.isIdentity() ? matrix
+						: matrix.appended(mx));
+			}
+		}
+	}
+},
+new function() {
+	function getCurrentPath(that, check) {
+		var children = that._children;
+		if (check && !children.length)
+			throw new Error('Use a moveTo() command first');
+		return children[children.length - 1];
+	}
+
+	return Base.each(['lineTo', 'cubicCurveTo', 'quadraticCurveTo', 'curveTo',
+			'arcTo', 'lineBy', 'cubicCurveBy', 'quadraticCurveBy', 'curveBy',
+			'arcBy'],
+		function(key) {
+			this[key] = function() {
+				var path = getCurrentPath(this, true);
+				path[key].apply(path, arguments);
+			};
+		}, {
+			moveTo: function() {
+				var current = getCurrentPath(this),
+					path = current && current.isEmpty() ? current
+							: new Path(Item.NO_INSERT);
+				if (path !== current)
+					this.addChild(path);
+				path.moveTo.apply(path, arguments);
+			},
+
+			moveBy: function() {
+				var current = getCurrentPath(this, true),
+					last = current && current.getLastSegment(),
+					point = Point.read(arguments);
+				this.moveTo(last ? point.add(last._point) : point);
+			},
+
+			closePath: function(tolerance) {
+				getCurrentPath(this, true).closePath(tolerance);
+			}
+		}
+	);
+}, Base.each(['reverse', 'flatten', 'simplify', 'smooth'], function(key) {
+	this[key] = function(param) {
+		var children = this._children,
+			res;
+		for (var i = 0, l = children.length; i < l; i++) {
+			res = children[i][key](param) || res;
+		}
+		return res;
+	};
+}, {}));
+
+PathItem.inject(new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		operators = {
+			unite:     { '1': true, '2': true },
+			intersect: { '2': true },
+			subtract:  { '1': true },
+			exclude:   { '1': true, '-1': true }
+		};
+
+	function getPaths(path) {
+		return path._children || [path];
+	}
+
+	function preparePath(path, resolve) {
+		var res = path
+			.clone(false)
+			.reduce({ simplify: true })
+			.transform(null, true, true);
+		if (resolve) {
+			var paths = getPaths(res);
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				if (!path._closed && !path.isEmpty()) {
+					path.closePath(1e-12);
+					path.getFirstSegment().setHandleIn(0, 0);
+					path.getLastSegment().setHandleOut(0, 0);
+				}
+			}
+			res = res
+				.resolveCrossings()
+				.reorient(res.getFillRule() === 'nonzero', true);
+		}
+		return res;
+	}
+
+	function createResult(paths, simplify, path1, path2, options) {
+		var result = new CompoundPath(Item.NO_INSERT);
+		result.addChildren(paths, true);
+		result = result.reduce({ simplify: simplify });
+		if (!(options && options.insert == false)) {
+			result.insertAbove(path2 && path1.isSibling(path2)
+					&& path1.getIndex() < path2.getIndex() ? path2 : path1);
+		}
+		result.copyAttributes(path1, true);
+		return result;
+	}
+
+	function filterIntersection(inter) {
+		return inter.hasOverlap() || inter.isCrossing();
+	}
+
+	function traceBoolean(path1, path2, operation, options) {
+		if (options && (options.trace == false || options.stroke) &&
+				/^(subtract|intersect)$/.test(operation))
+			return splitBoolean(path1, path2, operation);
+		var _path1 = preparePath(path1, true),
+			_path2 = path2 && path1 !== path2 && preparePath(path2, true),
+			operator = operators[operation];
+		operator[operation] = true;
+		if (_path2 && (operator.subtract || operator.exclude)
+				^ (_path2.isClockwise() ^ _path1.isClockwise()))
+			_path2.reverse();
+		var crossings = divideLocations(CurveLocation.expand(
+				_path1.getIntersections(_path2, filterIntersection))),
+			paths1 = getPaths(_path1),
+			paths2 = _path2 && getPaths(_path2),
+			segments = [],
+			curves = [],
+			paths;
+
+		function collectPaths(paths) {
+			for (var i = 0, l = paths.length; i < l; i++) {
+				var path = paths[i];
+				Base.push(segments, path._segments);
+				Base.push(curves, path.getCurves());
+				path._overlapsOnly = true;
+			}
+		}
+
+		function getCurves(indices) {
+			var list = [];
+			for (var i = 0, l = indices && indices.length; i < l; i++) {
+				list.push(curves[indices[i]]);
+			}
+			return list;
+		}
+
+		if (crossings.length) {
+			collectPaths(paths1);
+			if (paths2)
+				collectPaths(paths2);
+
+			var curvesValues = new Array(curves.length);
+			for (var i = 0, l = curves.length; i < l; i++) {
+				curvesValues[i] = curves[i].getValues();
+			}
+			var curveCollisions = CollisionDetection.findCurveBoundsCollisions(
+					curvesValues, curvesValues, 0, true);
+			var curveCollisionsMap = {};
+			for (var i = 0; i < curves.length; i++) {
+				var curve = curves[i],
+					id = curve._path._id,
+					map = curveCollisionsMap[id] = curveCollisionsMap[id] || {};
+				map[curve.getIndex()] = {
+					hor: getCurves(curveCollisions[i].hor),
+					ver: getCurves(curveCollisions[i].ver)
+				};
+			}
+
+			for (var i = 0, l = crossings.length; i < l; i++) {
+				propagateWinding(crossings[i]._segment, _path1, _path2,
+						curveCollisionsMap, operator);
+			}
+			for (var i = 0, l = segments.length; i < l; i++) {
+				var segment = segments[i],
+					inter = segment._intersection;
+				if (!segment._winding) {
+					propagateWinding(segment, _path1, _path2,
+							curveCollisionsMap, operator);
+				}
+				if (!(inter && inter._overlap))
+					segment._path._overlapsOnly = false;
+			}
+			paths = tracePaths(segments, operator);
+		} else {
+			paths = reorientPaths(
+					paths2 ? paths1.concat(paths2) : paths1.slice(),
+					function(w) {
+						return !!operator[w];
+					});
+		}
+		return createResult(paths, true, path1, path2, options);
+	}
+
+	function splitBoolean(path1, path2, operation) {
+		var _path1 = preparePath(path1),
+			_path2 = preparePath(path2),
+			crossings = _path1.getIntersections(_path2, filterIntersection),
+			subtract = operation === 'subtract',
+			divide = operation === 'divide',
+			added = {},
+			paths = [];
+
+		function addPath(path) {
+			if (!added[path._id] && (divide ||
+					_path2.contains(path.getPointAt(path.getLength() / 2))
+						^ subtract)) {
+				paths.unshift(path);
+				return added[path._id] = true;
+			}
+		}
+
+		for (var i = crossings.length - 1; i >= 0; i--) {
+			var path = crossings[i].split();
+			if (path) {
+				if (addPath(path))
+					path.getFirstSegment().setHandleIn(0, 0);
+				_path1.getLastSegment().setHandleOut(0, 0);
+			}
+		}
+		addPath(_path1);
+		return createResult(paths, false, path1, path2);
+	}
+
+	function linkIntersections(from, to) {
+		var prev = from;
+		while (prev) {
+			if (prev === to)
+				return;
+			prev = prev._previous;
+		}
+		while (from._next && from._next !== to)
+			from = from._next;
+		if (!from._next) {
+			while (to._previous)
+				to = to._previous;
+			from._next = to;
+			to._previous = from;
+		}
+	}
+
+	function clearCurveHandles(curves) {
+		for (var i = curves.length - 1; i >= 0; i--)
+			curves[i].clearHandles();
+	}
+
+	function reorientPaths(paths, isInside, clockwise) {
+		var length = paths && paths.length;
+		if (length) {
+			var lookup = Base.each(paths, function (path, i) {
+					this[path._id] = {
+						container: null,
+						winding: path.isClockwise() ? 1 : -1,
+						index: i
+					};
+				}, {}),
+				sorted = paths.slice().sort(function (a, b) {
+					return abs(b.getArea()) - abs(a.getArea());
+				}),
+				first = sorted[0];
+			var collisions = CollisionDetection.findItemBoundsCollisions(sorted,
+					null, Numerical.GEOMETRIC_EPSILON);
+			if (clockwise == null)
+				clockwise = first.isClockwise();
+			for (var i = 0; i < length; i++) {
+				var path1 = sorted[i],
+					entry1 = lookup[path1._id],
+					containerWinding = 0,
+					indices = collisions[i];
+				if (indices) {
+					var point = null;
+					for (var j = indices.length - 1; j >= 0; j--) {
+						if (indices[j] < i) {
+							point = point || path1.getInteriorPoint();
+							var path2 = sorted[indices[j]];
+							if (path2.contains(point)) {
+								var entry2 = lookup[path2._id];
+								containerWinding = entry2.winding;
+								entry1.winding += containerWinding;
+								entry1.container = entry2.exclude
+									? entry2.container : path2;
+								break;
+							}
+						}
+					}
+				}
+				if (isInside(entry1.winding) === isInside(containerWinding)) {
+					entry1.exclude = true;
+					paths[entry1.index] = null;
+				} else {
+					var container = entry1.container;
+					path1.setClockwise(
+							container ? !container.isClockwise() : clockwise);
+				}
+			}
+		}
+		return paths;
+	}
+
+	function divideLocations(locations, include, clearLater) {
+		var results = include && [],
+			tMin = 1e-8,
+			tMax = 1 - tMin,
+			clearHandles = false,
+			clearCurves = clearLater || [],
+			clearLookup = clearLater && {},
+			renormalizeLocs,
+			prevCurve,
+			prevTime;
+
+		function getId(curve) {
+			return curve._path._id + '.' + curve._segment1._index;
+		}
+
+		for (var i = (clearLater && clearLater.length) - 1; i >= 0; i--) {
+			var curve = clearLater[i];
+			if (curve._path)
+				clearLookup[getId(curve)] = true;
+		}
+
+		for (var i = locations.length - 1; i >= 0; i--) {
+			var loc = locations[i],
+				time = loc._time,
+				origTime = time,
+				exclude = include && !include(loc),
+				curve = loc._curve,
+				segment;
+			if (curve) {
+				if (curve !== prevCurve) {
+					clearHandles = !curve.hasHandles()
+							|| clearLookup && clearLookup[getId(curve)];
+					renormalizeLocs = [];
+					prevTime = null;
+					prevCurve = curve;
+				} else if (prevTime >= tMin) {
+					time /= prevTime;
+				}
+			}
+			if (exclude) {
+				if (renormalizeLocs)
+					renormalizeLocs.push(loc);
+				continue;
+			} else if (include) {
+				results.unshift(loc);
+			}
+			prevTime = origTime;
+			if (time < tMin) {
+				segment = curve._segment1;
+			} else if (time > tMax) {
+				segment = curve._segment2;
+			} else {
+				var newCurve = curve.divideAtTime(time, true);
+				if (clearHandles)
+					clearCurves.push(curve, newCurve);
+				segment = newCurve._segment1;
+				for (var j = renormalizeLocs.length - 1; j >= 0; j--) {
+					var l = renormalizeLocs[j];
+					l._time = (l._time - time) / (1 - time);
+				}
+			}
+			loc._setSegment(segment);
+			var inter = segment._intersection,
+				dest = loc._intersection;
+			if (inter) {
+				linkIntersections(inter, dest);
+				var other = inter;
+				while (other) {
+					linkIntersections(other._intersection, inter);
+					other = other._next;
+				}
+			} else {
+				segment._intersection = dest;
+			}
+		}
+		if (!clearLater)
+			clearCurveHandles(clearCurves);
+		return results || locations;
+	}
+
+	function getWinding(point, curves, dir, closed, dontFlip) {
+		var curvesList = Array.isArray(curves)
+			? curves
+			: curves[dir ? 'hor' : 'ver'];
+		var ia = dir ? 1 : 0,
+			io = ia ^ 1,
+			pv = [point.x, point.y],
+			pa = pv[ia],
+			po = pv[io],
+			windingEpsilon = 1e-9,
+			qualityEpsilon = 1e-6,
+			paL = pa - windingEpsilon,
+			paR = pa + windingEpsilon,
+			windingL = 0,
+			windingR = 0,
+			pathWindingL = 0,
+			pathWindingR = 0,
+			onPath = false,
+			onAnyPath = false,
+			quality = 1,
+			roots = [],
+			vPrev,
+			vClose;
+
+		function addWinding(v) {
+			var o0 = v[io + 0],
+				o3 = v[io + 6];
+			if (po < min(o0, o3) || po > max(o0, o3)) {
+				return;
+			}
+			var a0 = v[ia + 0],
+				a1 = v[ia + 2],
+				a2 = v[ia + 4],
+				a3 = v[ia + 6];
+			if (o0 === o3) {
+				if (a0 < paR && a3 > paL || a3 < paR && a0 > paL) {
+					onPath = true;
+				}
+				return;
+			}
+			var t =   po === o0 ? 0
+					: po === o3 ? 1
+					: paL > max(a0, a1, a2, a3) || paR < min(a0, a1, a2, a3)
+					? 1
+					: Curve.solveCubic(v, io, po, roots, 0, 1) > 0
+						? roots[0]
+						: 1,
+				a =   t === 0 ? a0
+					: t === 1 ? a3
+					: Curve.getPoint(v, t)[dir ? 'y' : 'x'],
+				winding = o0 > o3 ? 1 : -1,
+				windingPrev = vPrev[io] > vPrev[io + 6] ? 1 : -1,
+				a3Prev = vPrev[ia + 6];
+			if (po !== o0) {
+				if (a < paL) {
+					pathWindingL += winding;
+				} else if (a > paR) {
+					pathWindingR += winding;
+				} else {
+					onPath = true;
+				}
+				if (a > pa - qualityEpsilon && a < pa + qualityEpsilon)
+					quality /= 2;
+			} else {
+				if (winding !== windingPrev) {
+					if (a0 < paL) {
+						pathWindingL += winding;
+					} else if (a0 > paR) {
+						pathWindingR += winding;
+					}
+				} else if (a0 != a3Prev) {
+					if (a3Prev < paR && a > paR) {
+						pathWindingR += winding;
+						onPath = true;
+					} else if (a3Prev > paL && a < paL) {
+						pathWindingL += winding;
+						onPath = true;
+					}
+				}
+				quality /= 4;
+			}
+			vPrev = v;
+			return !dontFlip && a > paL && a < paR
+					&& Curve.getTangent(v, t)[dir ? 'x' : 'y'] === 0
+					&& getWinding(point, curves, !dir, closed, true);
+		}
+
+		function handleCurve(v) {
+			var o0 = v[io + 0],
+				o1 = v[io + 2],
+				o2 = v[io + 4],
+				o3 = v[io + 6];
+			if (po <= max(o0, o1, o2, o3) && po >= min(o0, o1, o2, o3)) {
+				var a0 = v[ia + 0],
+					a1 = v[ia + 2],
+					a2 = v[ia + 4],
+					a3 = v[ia + 6],
+					monoCurves = paL > max(a0, a1, a2, a3) ||
+								 paR < min(a0, a1, a2, a3)
+							? [v] : Curve.getMonoCurves(v, dir),
+					res;
+				for (var i = 0, l = monoCurves.length; i < l; i++) {
+					if (res = addWinding(monoCurves[i]))
+						return res;
+				}
+			}
+		}
+
+		for (var i = 0, l = curvesList.length; i < l; i++) {
+			var curve = curvesList[i],
+				path = curve._path,
+				v = curve.getValues(),
+				res;
+			if (!i || curvesList[i - 1]._path !== path) {
+				vPrev = null;
+				if (!path._closed) {
+					vClose = Curve.getValues(
+							path.getLastCurve().getSegment2(),
+							curve.getSegment1(),
+							null, !closed);
+					if (vClose[io] !== vClose[io + 6]) {
+						vPrev = vClose;
+					}
+				}
+
+				if (!vPrev) {
+					vPrev = v;
+					var prev = path.getLastCurve();
+					while (prev && prev !== curve) {
+						var v2 = prev.getValues();
+						if (v2[io] !== v2[io + 6]) {
+							vPrev = v2;
+							break;
+						}
+						prev = prev.getPrevious();
+					}
+				}
+			}
+
+			if (res = handleCurve(v))
+				return res;
+
+			if (i + 1 === l || curvesList[i + 1]._path !== path) {
+				if (vClose && (res = handleCurve(vClose)))
+					return res;
+				if (onPath && !pathWindingL && !pathWindingR) {
+					pathWindingL = pathWindingR = path.isClockwise(closed) ^ dir
+							? 1 : -1;
+				}
+				windingL += pathWindingL;
+				windingR += pathWindingR;
+				pathWindingL = pathWindingR = 0;
+				if (onPath) {
+					onAnyPath = true;
+					onPath = false;
+				}
+				vClose = null;
+			}
+		}
+		windingL = abs(windingL);
+		windingR = abs(windingR);
+		return {
+			winding: max(windingL, windingR),
+			windingL: windingL,
+			windingR: windingR,
+			quality: quality,
+			onPath: onAnyPath
+		};
+	}
+
+	function propagateWinding(segment, path1, path2, curveCollisionsMap,
+			operator) {
+		var chain = [],
+			start = segment,
+			totalLength = 0,
+			winding;
+		do {
+			var curve = segment.getCurve();
+			if (curve) {
+				var length = curve.getLength();
+				chain.push({ segment: segment, curve: curve, length: length });
+				totalLength += length;
+			}
+			segment = segment.getNext();
+		} while (segment && !segment._intersection && segment !== start);
+		var offsets = [0.5, 0.25, 0.75],
+			winding = { winding: 0, quality: -1 },
+			tMin = 1e-3,
+			tMax = 1 - tMin;
+		for (var i = 0; i < offsets.length && winding.quality < 0.5; i++) {
+			var length = totalLength * offsets[i];
+			for (var j = 0, l = chain.length; j < l; j++) {
+				var entry = chain[j],
+					curveLength = entry.length;
+				if (length <= curveLength) {
+					var curve = entry.curve,
+						path = curve._path,
+						parent = path._parent,
+						operand = parent instanceof CompoundPath ? parent : path,
+						t = Numerical.clamp(curve.getTimeAt(length), tMin, tMax),
+						pt = curve.getPointAtTime(t),
+						dir = abs(curve.getTangentAtTime(t).y) < Math.SQRT1_2;
+					var wind = null;
+					if (operator.subtract && path2) {
+						var otherPath = operand === path1 ? path2 : path1,
+							pathWinding = otherPath._getWinding(pt, dir, true);
+						if (operand === path1 && pathWinding.winding ||
+							operand === path2 && !pathWinding.winding) {
+							if (pathWinding.quality < 1) {
+								continue;
+							} else {
+								wind = { winding: 0, quality: 1 };
+							}
+						}
+					}
+					wind =  wind || getWinding(
+							pt, curveCollisionsMap[path._id][curve.getIndex()],
+							dir, true);
+					if (wind.quality > winding.quality)
+						winding = wind;
+					break;
+				}
+				length -= curveLength;
+			}
+		}
+		for (var j = chain.length - 1; j >= 0; j--) {
+			chain[j].segment._winding = winding;
+		}
+	}
+
+	function tracePaths(segments, operator) {
+		var paths = [],
+			starts;
+
+		function isValid(seg) {
+			var winding;
+			return !!(seg && !seg._visited && (!operator
+					|| operator[(winding = seg._winding || {}).winding]
+						&& !(operator.unite && winding.winding === 2
+							&& winding.windingL && winding.windingR)));
+		}
+
+		function isStart(seg) {
+			if (seg) {
+				for (var i = 0, l = starts.length; i < l; i++) {
+					if (seg === starts[i])
+						return true;
+				}
+			}
+			return false;
+		}
+
+		function visitPath(path) {
+			var segments = path._segments;
+			for (var i = 0, l = segments.length; i < l; i++) {
+				segments[i]._visited = true;
+			}
+		}
+
+		function getCrossingSegments(segment, collectStarts) {
+			var inter = segment._intersection,
+				start = inter,
+				crossings = [];
+			if (collectStarts)
+				starts = [segment];
+
+			function collect(inter, end) {
+				while (inter && inter !== end) {
+					var other = inter._segment,
+						path = other && other._path;
+					if (path) {
+						var next = other.getNext() || path.getFirstSegment(),
+							nextInter = next._intersection;
+						if (other !== segment && (isStart(other)
+							|| isStart(next)
+							|| next && (isValid(other) && (isValid(next)
+								|| nextInter && isValid(nextInter._segment))))
+						) {
+							crossings.push(other);
+						}
+						if (collectStarts)
+							starts.push(other);
+					}
+					inter = inter._next;
+				}
+			}
+
+			if (inter) {
+				collect(inter);
+				while (inter && inter._previous)
+					inter = inter._previous;
+				collect(inter, start);
+			}
+			return crossings;
+		}
+
+		segments.sort(function(seg1, seg2) {
+			var inter1 = seg1._intersection,
+				inter2 = seg2._intersection,
+				over1 = !!(inter1 && inter1._overlap),
+				over2 = !!(inter2 && inter2._overlap),
+				path1 = seg1._path,
+				path2 = seg2._path;
+			return over1 ^ over2
+					? over1 ? 1 : -1
+					: !inter1 ^ !inter2
+						? inter1 ? 1 : -1
+						: path1 !== path2
+							? path1._id - path2._id
+							: seg1._index - seg2._index;
+		});
+
+		for (var i = 0, l = segments.length; i < l; i++) {
+			var seg = segments[i],
+				valid = isValid(seg),
+				path = null,
+				finished = false,
+				closed = true,
+				branches = [],
+				branch,
+				visited,
+				handleIn;
+			if (valid && seg._path._overlapsOnly) {
+				var path1 = seg._path,
+					path2 = seg._intersection._segment._path;
+				if (path1.compare(path2)) {
+					if (path1.getArea())
+						paths.push(path1.clone(false));
+					visitPath(path1);
+					visitPath(path2);
+					valid = false;
+				}
+			}
+			while (valid) {
+				var first = !path,
+					crossings = getCrossingSegments(seg, first),
+					other = crossings.shift(),
+					finished = !first && (isStart(seg) || isStart(other)),
+					cross = !finished && other;
+				if (first) {
+					path = new Path(Item.NO_INSERT);
+					branch = null;
+				}
+				if (finished) {
+					if (seg.isFirst() || seg.isLast())
+						closed = seg._path._closed;
+					seg._visited = true;
+					break;
+				}
+				if (cross && branch) {
+					branches.push(branch);
+					branch = null;
+				}
+				if (!branch) {
+					if (cross)
+						crossings.push(seg);
+					branch = {
+						start: path._segments.length,
+						crossings: crossings,
+						visited: visited = [],
+						handleIn: handleIn
+					};
+				}
+				if (cross)
+					seg = other;
+				if (!isValid(seg)) {
+					path.removeSegments(branch.start);
+					for (var j = 0, k = visited.length; j < k; j++) {
+						visited[j]._visited = false;
+					}
+					visited.length = 0;
+					do {
+						seg = branch && branch.crossings.shift();
+						if (!seg || !seg._path) {
+							seg = null;
+							branch = branches.pop();
+							if (branch) {
+								visited = branch.visited;
+								handleIn = branch.handleIn;
+							}
+						}
+					} while (branch && !isValid(seg));
+					if (!seg)
+						break;
+				}
+				var next = seg.getNext();
+				path.add(new Segment(seg._point, handleIn,
+						next && seg._handleOut));
+				seg._visited = true;
+				visited.push(seg);
+				seg = next || seg._path.getFirstSegment();
+				handleIn = next && next._handleIn;
+			}
+			if (finished) {
+				if (closed) {
+					path.getFirstSegment().setHandleIn(handleIn);
+					path.setClosed(closed);
+				}
+				if (path.getArea() !== 0) {
+					paths.push(path);
+				}
+			}
+		}
+		return paths;
+	}
+
+	return {
+		_getWinding: function(point, dir, closed) {
+			return getWinding(point, this.getCurves(), dir, closed);
+		},
+
+		unite: function(path, options) {
+			return traceBoolean(this, path, 'unite', options);
+		},
+
+		intersect: function(path, options) {
+			return traceBoolean(this, path, 'intersect', options);
+		},
+
+		subtract: function(path, options) {
+			return traceBoolean(this, path, 'subtract', options);
+		},
+
+		exclude: function(path, options) {
+			return traceBoolean(this, path, 'exclude', options);
+		},
+
+		divide: function(path, options) {
+			return options && (options.trace == false || options.stroke)
+					? splitBoolean(this, path, 'divide')
+					: createResult([
+						this.subtract(path, options),
+						this.intersect(path, options)
+					], true, this, path, options);
+		},
+
+		resolveCrossings: function() {
+			var children = this._children,
+				paths = children || [this];
+
+			function hasOverlap(seg, path) {
+				var inter = seg && seg._intersection;
+				return inter && inter._overlap && inter._path === path;
+			}
+
+			var hasOverlaps = false,
+				hasCrossings = false,
+				intersections = this.getIntersections(null, function(inter) {
+					return inter.hasOverlap() && (hasOverlaps = true) ||
+							inter.isCrossing() && (hasCrossings = true);
+				}),
+				clearCurves = hasOverlaps && hasCrossings && [];
+			intersections = CurveLocation.expand(intersections);
+			if (hasOverlaps) {
+				var overlaps = divideLocations(intersections, function(inter) {
+					return inter.hasOverlap();
+				}, clearCurves);
+				for (var i = overlaps.length - 1; i >= 0; i--) {
+					var overlap = overlaps[i],
+						path = overlap._path,
+						seg = overlap._segment,
+						prev = seg.getPrevious(),
+						next = seg.getNext();
+					if (hasOverlap(prev, path) && hasOverlap(next, path)) {
+						seg.remove();
+						prev._handleOut._set(0, 0);
+						next._handleIn._set(0, 0);
+						if (prev !== seg && !prev.getCurve().hasLength()) {
+							next._handleIn.set(prev._handleIn);
+							prev.remove();
+						}
+					}
+				}
+			}
+			if (hasCrossings) {
+				divideLocations(intersections, hasOverlaps && function(inter) {
+					var curve1 = inter.getCurve(),
+						seg1 = inter.getSegment(),
+						other = inter._intersection,
+						curve2 = other._curve,
+						seg2 = other._segment;
+					if (curve1 && curve2 && curve1._path && curve2._path)
+						return true;
+					if (seg1)
+						seg1._intersection = null;
+					if (seg2)
+						seg2._intersection = null;
+				}, clearCurves);
+				if (clearCurves)
+					clearCurveHandles(clearCurves);
+				paths = tracePaths(Base.each(paths, function(path) {
+					Base.push(this, path._segments);
+				}, []));
+			}
+			var length = paths.length,
+				item;
+			if (length > 1 && children) {
+				if (paths !== children)
+					this.setChildren(paths);
+				item = this;
+			} else if (length === 1 && !children) {
+				if (paths[0] !== this)
+					this.setSegments(paths[0].removeSegments());
+				item = this;
+			}
+			if (!item) {
+				item = new CompoundPath(Item.NO_INSERT);
+				item.addChildren(paths);
+				item = item.reduce();
+				item.copyAttributes(this);
+				this.replaceWith(item);
+			}
+			return item;
+		},
+
+		reorient: function(nonZero, clockwise) {
+			var children = this._children;
+			if (children && children.length) {
+				this.setChildren(reorientPaths(this.removeChildren(),
+						function(w) {
+							return !!(nonZero ? w : w & 1);
+						},
+						clockwise));
+			} else if (clockwise !== undefined) {
+				this.setClockwise(clockwise);
+			}
+			return this;
+		},
+
+		getInteriorPoint: function() {
+			var bounds = this.getBounds(),
+				point = bounds.getCenter(true);
+			if (!this.contains(point)) {
+				var curves = this.getCurves(),
+					y = point.y,
+					intercepts = [],
+					roots = [];
+				for (var i = 0, l = curves.length; i < l; i++) {
+					var v = curves[i].getValues(),
+						o0 = v[1],
+						o1 = v[3],
+						o2 = v[5],
+						o3 = v[7];
+					if (y >= min(o0, o1, o2, o3) && y <= max(o0, o1, o2, o3)) {
+						var monoCurves = Curve.getMonoCurves(v);
+						for (var j = 0, m = monoCurves.length; j < m; j++) {
+							var mv = monoCurves[j],
+								mo0 = mv[1],
+								mo3 = mv[7];
+							if ((mo0 !== mo3) &&
+								(y >= mo0 && y <= mo3 || y >= mo3 && y <= mo0)){
+								var x = y === mo0 ? mv[0]
+									: y === mo3 ? mv[6]
+									: Curve.solveCubic(mv, 1, y, roots, 0, 1)
+										=== 1
+										? Curve.getPoint(mv, roots[0]).x
+										: (mv[0] + mv[6]) / 2;
+								intercepts.push(x);
+							}
+						}
+					}
+				}
+				if (intercepts.length > 1) {
+					intercepts.sort(function(a, b) { return a - b; });
+					point.x = (intercepts[0] + intercepts[1]) / 2;
+				}
+			}
+			return point;
+		}
+	};
+});
+
+var PathFlattener = Base.extend({
+	_class: 'PathFlattener',
+
+	initialize: function(path, flatness, maxRecursion, ignoreStraight, matrix) {
+		var curves = [],
+			parts = [],
+			length = 0,
+			minSpan = 1 / (maxRecursion || 32),
+			segments = path._segments,
+			segment1 = segments[0],
+			segment2;
+
+		function addCurve(segment1, segment2) {
+			var curve = Curve.getValues(segment1, segment2, matrix);
+			curves.push(curve);
+			computeParts(curve, segment1._index, 0, 1);
+		}
+
+		function computeParts(curve, index, t1, t2) {
+			if ((t2 - t1) > minSpan
+					&& !(ignoreStraight && Curve.isStraight(curve))
+					&& !Curve.isFlatEnough(curve, flatness || 0.25)) {
+				var halves = Curve.subdivide(curve, 0.5),
+					tMid = (t1 + t2) / 2;
+				computeParts(halves[0], index, t1, tMid);
+				computeParts(halves[1], index, tMid, t2);
+			} else {
+				var dx = curve[6] - curve[0],
+					dy = curve[7] - curve[1],
+					dist = Math.sqrt(dx * dx + dy * dy);
+				if (dist > 0) {
+					length += dist;
+					parts.push({
+						offset: length,
+						curve: curve,
+						index: index,
+						time: t2,
+					});
+				}
+			}
+		}
+
+		for (var i = 1, l = segments.length; i < l; i++) {
+			segment2 = segments[i];
+			addCurve(segment1, segment2);
+			segment1 = segment2;
+		}
+		if (path._closed)
+			addCurve(segment2 || segment1, segments[0]);
+		this.curves = curves;
+		this.parts = parts;
+		this.length = length;
+		this.index = 0;
+	},
+
+	_get: function(offset) {
+		var parts = this.parts,
+			length = parts.length,
+			start,
+			i, j = this.index;
+		for (;;) {
+			i = j;
+			if (!j || parts[--j].offset < offset)
+				break;
+		}
+		for (; i < length; i++) {
+			var part = parts[i];
+			if (part.offset >= offset) {
+				this.index = i;
+				var prev = parts[i - 1],
+					prevTime = prev && prev.index === part.index ? prev.time : 0,
+					prevOffset = prev ? prev.offset : 0;
+				return {
+					index: part.index,
+					time: prevTime + (part.time - prevTime)
+						* (offset - prevOffset) / (part.offset - prevOffset)
+				};
+			}
+		}
+		return {
+			index: parts[length - 1].index,
+			time: 1
+		};
+	},
+
+	drawPart: function(ctx, from, to) {
+		var start = this._get(from),
+			end = this._get(to);
+		for (var i = start.index, l = end.index; i <= l; i++) {
+			var curve = Curve.getPart(this.curves[i],
+					i === start.index ? start.time : 0,
+					i === end.index ? end.time : 1);
+			if (i === start.index)
+				ctx.moveTo(curve[0], curve[1]);
+			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
+		}
+	}
+}, Base.each(Curve._evaluateMethods,
+	function(name) {
+		this[name + 'At'] = function(offset) {
+			var param = this._get(offset);
+			return Curve[name](this.curves[param.index], param.time);
+		};
+	}, {})
+);
+
+var PathFitter = Base.extend({
+	initialize: function(path) {
+		var points = this.points = [],
+			segments = path._segments,
+			closed = path._closed;
+		for (var i = 0, prev, l = segments.length; i < l; i++) {
+			var point = segments[i].point;
+			if (!prev || !prev.equals(point)) {
+				points.push(prev = point.clone());
+			}
+		}
+		if (closed) {
+			points.unshift(points[points.length - 1]);
+			points.push(points[1]);
+		}
+		this.closed = closed;
+	},
+
+	fit: function(error) {
+		var points = this.points,
+			length = points.length,
+			segments = null;
+		if (length > 0) {
+			segments = [new Segment(points[0])];
+			if (length > 1) {
+				this.fitCubic(segments, error, 0, length - 1,
+						points[1].subtract(points[0]),
+						points[length - 2].subtract(points[length - 1]));
+				if (this.closed) {
+					segments.shift();
+					segments.pop();
+				}
+			}
+		}
+		return segments;
+	},
+
+	fitCubic: function(segments, error, first, last, tan1, tan2) {
+		var points = this.points;
+		if (last - first === 1) {
+			var pt1 = points[first],
+				pt2 = points[last],
+				dist = pt1.getDistance(pt2) / 3;
+			this.addCurve(segments, [pt1, pt1.add(tan1.normalize(dist)),
+					pt2.add(tan2.normalize(dist)), pt2]);
+			return;
+		}
+		var uPrime = this.chordLengthParameterize(first, last),
+			maxError = Math.max(error, error * error),
+			split,
+			parametersInOrder = true;
+		for (var i = 0; i <= 4; i++) {
+			var curve = this.generateBezier(first, last, uPrime, tan1, tan2);
+			var max = this.findMaxError(first, last, curve, uPrime);
+			if (max.error < error && parametersInOrder) {
+				this.addCurve(segments, curve);
+				return;
+			}
+			split = max.index;
+			if (max.error >= maxError)
+				break;
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
+			maxError = max.error;
+		}
+		var tanCenter = points[split - 1].subtract(points[split + 1]);
+		this.fitCubic(segments, error, first, split, tan1, tanCenter);
+		this.fitCubic(segments, error, split, last, tanCenter.negate(), tan2);
+	},
+
+	addCurve: function(segments, curve) {
+		var prev = segments[segments.length - 1];
+		prev.setHandleOut(curve[1].subtract(curve[0]));
+		segments.push(new Segment(curve[3], curve[2].subtract(curve[3])));
+	},
+
+	generateBezier: function(first, last, uPrime, tan1, tan2) {
+		var epsilon = 1e-12,
+			abs = Math.abs,
+			points = this.points,
+			pt1 = points[first],
+			pt2 = points[last],
+			C = [[0, 0], [0, 0]],
+			X = [0, 0];
+
+		for (var i = 0, l = last - first + 1; i < l; i++) {
+			var u = uPrime[i],
+				t = 1 - u,
+				b = 3 * u * t,
+				b0 = t * t * t,
+				b1 = b * t,
+				b2 = b * u,
+				b3 = u * u * u,
+				a1 = tan1.normalize(b1),
+				a2 = tan2.normalize(b2),
+				tmp = points[first + i]
+					.subtract(pt1.multiply(b0 + b1))
+					.subtract(pt2.multiply(b2 + b3));
+			C[0][0] += a1.dot(a1);
+			C[0][1] += a1.dot(a2);
+			C[1][0] = C[0][1];
+			C[1][1] += a2.dot(a2);
+			X[0] += a1.dot(tmp);
+			X[1] += a2.dot(tmp);
+		}
+
+		var detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1],
+			alpha1,
+			alpha2;
+		if (abs(detC0C1) > epsilon) {
+			var detC0X = C[0][0] * X[1]    - C[1][0] * X[0],
+				detXC1 = X[0]    * C[1][1] - X[1]    * C[0][1];
+			alpha1 = detXC1 / detC0C1;
+			alpha2 = detC0X / detC0C1;
+		} else {
+			var c0 = C[0][0] + C[0][1],
+				c1 = C[1][0] + C[1][1];
+			alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0
+							: abs(c1) > epsilon ? X[1] / c1
+							: 0;
+		}
+
+		var segLength = pt2.getDistance(pt1),
+			eps = epsilon * segLength,
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
+			alpha1 = alpha2 = segLength / 3;
+		} else {
+			var line = pt2.subtract(pt1);
+			handle1 = tan1.normalize(alpha1);
+			handle2 = tan2.normalize(alpha2);
+			if (handle1.dot(line) - handle2.dot(line) > segLength * segLength) {
+				alpha1 = alpha2 = segLength / 3;
+				handle1 = handle2 = null;
+			}
+		}
+
+		return [pt1,
+				pt1.add(handle1 || tan1.normalize(alpha1)),
+				pt2.add(handle2 || tan2.normalize(alpha2)),
+				pt2];
+	},
+
+	reparameterize: function(first, last, u, curve) {
+		for (var i = first; i <= last; i++) {
+			u[i - first] = this.findRoot(curve, this.points[i], u[i - first]);
+		}
+		for (var i = 1, l = u.length; i < l; i++) {
+			if (u[i] <= u[i - 1])
+				return false;
+		}
+		return true;
+	},
+
+	findRoot: function(curve, point, u) {
+		var curve1 = [],
+			curve2 = [];
+		for (var i = 0; i <= 2; i++) {
+			curve1[i] = curve[i + 1].subtract(curve[i]).multiply(3);
+		}
+		for (var i = 0; i <= 1; i++) {
+			curve2[i] = curve1[i + 1].subtract(curve1[i]).multiply(2);
+		}
+		var pt = this.evaluate(3, curve, u),
+			pt1 = this.evaluate(2, curve1, u),
+			pt2 = this.evaluate(1, curve2, u),
+			diff = pt.subtract(point),
+			df = pt1.dot(pt1) + diff.dot(pt2);
+		return Numerical.isMachineZero(df) ? u : u - diff.dot(pt1) / df;
+	},
+
+	evaluate: function(degree, curve, t) {
+		var tmp = curve.slice();
+		for (var i = 1; i <= degree; i++) {
+			for (var j = 0; j <= degree - i; j++) {
+				tmp[j] = tmp[j].multiply(1 - t).add(tmp[j + 1].multiply(t));
+			}
+		}
+		return tmp[0];
+	},
+
+	chordLengthParameterize: function(first, last) {
+		var u = [0];
+		for (var i = first + 1; i <= last; i++) {
+			u[i - first] = u[i - first - 1]
+					+ this.points[i].getDistance(this.points[i - 1]);
+		}
+		for (var i = 1, m = last - first; i <= m; i++) {
+			u[i] /= u[m];
+		}
+		return u;
+	},
+
+	findMaxError: function(first, last, curve, u) {
+		var index = Math.floor((last - first + 1) / 2),
+			maxDist = 0;
+		for (var i = first + 1; i < last; i++) {
+			var P = this.evaluate(3, curve, u[i - first]);
+			var v = P.subtract(this.points[i]);
+			var dist = v.x * v.x + v.y * v.y;
+			if (dist >= maxDist) {
+				maxDist = dist;
+				index = i;
+			}
+		}
+		return {
+			error: maxDist,
+			index: index
+		};
+	}
+});
+
+var TextItem = Item.extend({
+	_class: 'TextItem',
+	_applyMatrix: false,
+	_canApplyMatrix: false,
+	_serializeFields: {
+		content: null
+	},
+	_boundsOptions: { stroke: false, handle: false },
+
+	initialize: function TextItem(arg) {
+		this._content = '';
+		this._lines = [];
+		var hasProps = arg && Base.isPlainObject(arg)
+				&& arg.x === undefined && arg.y === undefined;
+		this._initialize(hasProps && arg, !hasProps && Point.read(arguments));
+	},
+
+	_equals: function(item) {
+		return this._content === item._content;
+	},
+
+	copyContent: function(source) {
+		this.setContent(source._content);
+	},
+
+	getContent: function() {
+		return this._content;
+	},
+
+	setContent: function(content) {
+		this._content = '' + content;
+		this._lines = this._content.split(/\r\n|\n|\r/mg);
+		this._changed(521);
+	},
+
+	isEmpty: function() {
+		return !this._content;
+	},
+
+	getCharacterStyle: '#getStyle',
+	setCharacterStyle: '#setStyle',
+
+	getParagraphStyle: '#getStyle',
+	setParagraphStyle: '#setStyle'
+});
+
+var PointText = TextItem.extend({
+	_class: 'PointText',
+
+	initialize: function PointText() {
+		TextItem.apply(this, arguments);
+	},
+
+	getPoint: function() {
+		var point = this._matrix.getTranslation();
+		return new LinkedPoint(point.x, point.y, this, 'setPoint');
+	},
+
+	setPoint: function() {
+		var point = Point.read(arguments);
+		this.translate(point.subtract(this._matrix.getTranslation()));
+	},
+
+	_draw: function(ctx, param, viewMatrix) {
+		if (!this._content)
+			return;
+		this._setStyles(ctx, param, viewMatrix);
+		var lines = this._lines,
+			style = this._style,
+			hasFill = style.hasFill(),
+			hasStroke = style.hasStroke(),
+			leading = style.getLeading(),
+			shadowColor = ctx.shadowColor;
+		ctx.font = style.getFontStyle();
+		ctx.textAlign = style.getJustification();
+		for (var i = 0, l = lines.length; i < l; i++) {
+			ctx.shadowColor = shadowColor;
+			var line = lines[i];
+			if (hasFill) {
+				ctx.fillText(line, 0, 0);
+				ctx.shadowColor = 'rgba(0,0,0,0)';
+			}
+			if (hasStroke)
+				ctx.strokeText(line, 0, 0);
+			ctx.translate(0, leading);
+		}
+	},
+
+	_getBounds: function(matrix, options) {
+		var style = this._style,
+			lines = this._lines,
+			numLines = lines.length,
+			justification = style.getJustification(),
+			leading = style.getLeading(),
+			width = this.getView().getTextWidth(style.getFontStyle(), lines),
+			x = 0;
+		if (justification !== 'left')
+			x -= width / (justification === 'center' ? 2: 1);
+		var rect = new Rectangle(x,
+					numLines ? - 0.75 * leading : 0,
+					width, numLines * leading);
+		return matrix ? matrix._transformBounds(rect, rect) : rect;
+	}
+});
+
+var Color = Base.extend(new function() {
+	var types = {
+		gray: ['gray'],
+		rgb: ['red', 'green', 'blue'],
+		hsb: ['hue', 'saturation', 'brightness'],
+		hsl: ['hue', 'saturation', 'lightness'],
+		gradient: ['gradient', 'origin', 'destination', 'highlight']
+	};
+
+	var componentParsers = {},
+		namedColors = {
+			transparent: [0, 0, 0, 0]
+		},
+		colorCtx;
+
+	function fromCSS(string) {
+		var match = string.match(
+				/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i
+			) || string.match(
+				/^#([\da-f])([\da-f])([\da-f])([\da-f])?$/i
+			),
+			type = 'rgb',
+			components;
+		if (match) {
+			var amount = match[4] ? 4 : 3;
+			components = new Array(amount);
+			for (var i = 0; i < amount; i++) {
+				var value = match[i + 1];
+				components[i] = parseInt(value.length == 1
+						? value + value : value, 16) / 255;
+			}
+		} else if (match = string.match(/^(rgb|hsl)a?\((.*)\)$/)) {
+			type = match[1];
+			components = match[2].trim().split(/[,\s]+/g);
+			var isHSL = type === 'hsl';
+			for (var i = 0, l = Math.min(components.length, 4); i < l; i++) {
+				var component = components[i];
+				var value = parseFloat(component);
+				if (isHSL) {
+					if (i === 0) {
+						var unit = component.match(/([a-z]*)$/)[1];
+						value *= ({
+							turn: 360,
+							rad: 180 / Math.PI,
+							grad: 0.9
+						}[unit] || 1);
+					} else if (i < 3) {
+						value /= 100;
+					}
+				} else if (i < 3) {
+					value /= /%$/.test(component) ? 100 : 255;
+				}
+				components[i] = value;
+			}
+		} else {
+			var color = namedColors[string];
+			if (!color) {
+				if (window) {
+					if (!colorCtx) {
+						colorCtx = CanvasProvider.getContext(1, 1);
+						colorCtx.globalCompositeOperation = 'copy';
+					}
+					colorCtx.fillStyle = 'rgba(0,0,0,0)';
+					colorCtx.fillStyle = string;
+					colorCtx.fillRect(0, 0, 1, 1);
+					var data = colorCtx.getImageData(0, 0, 1, 1).data;
+					color = namedColors[string] = [
+						data[0] / 255,
+						data[1] / 255,
+						data[2] / 255
+					];
+				} else {
+					color = [0, 0, 0];
+				}
+			}
+			components = color.slice();
+		}
+		return [type, components];
+	}
+
+	var hsbIndices = [
+		[0, 3, 1],
+		[2, 0, 1],
+		[1, 0, 3],
+		[1, 2, 0],
+		[3, 1, 0],
+		[0, 1, 2]
+	];
+
+	var converters = {
+		'rgb-hsb': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				h = delta === 0 ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60;
+			return [h, max === 0 ? 0 : delta / max, max];
+		},
+
+		'hsb-rgb': function(h, s, b) {
+			h = (((h / 60) % 6) + 6) % 6;
+			var i = Math.floor(h),
+				f = h - i,
+				i = hsbIndices[i],
+				v = [
+					b,
+					b * (1 - s),
+					b * (1 - s * f),
+					b * (1 - s * (1 - f))
+				];
+			return [v[i[0]], v[i[1]], v[i[2]]];
+		},
+
+		'rgb-hsl': function(r, g, b) {
+			var max = Math.max(r, g, b),
+				min = Math.min(r, g, b),
+				delta = max - min,
+				achromatic = delta === 0,
+				h = achromatic ? 0
+					:   ( max == r ? (g - b) / delta + (g < b ? 6 : 0)
+						: max == g ? (b - r) / delta + 2
+						:            (r - g) / delta + 4) * 60,
+				l = (max + min) / 2,
+				s = achromatic ? 0 : l < 0.5
+						? delta / (max + min)
+						: delta / (2 - max - min);
+			return [h, s, l];
+		},
+
+		'hsl-rgb': function(h, s, l) {
+			h = (((h / 360) % 1) + 1) % 1;
+			if (s === 0)
+				return [l, l, l];
+			var t3s = [ h + 1 / 3, h, h - 1 / 3 ],
+				t2 = l < 0.5 ? l * (1 + s) : l + s - l * s,
+				t1 = 2 * l - t2,
+				c = [];
+			for (var i = 0; i < 3; i++) {
+				var t3 = t3s[i];
+				if (t3 < 0) t3 += 1;
+				if (t3 > 1) t3 -= 1;
+				c[i] = 6 * t3 < 1
+					? t1 + (t2 - t1) * 6 * t3
+					: 2 * t3 < 1
+						? t2
+						: 3 * t3 < 2
+							? t1 + (t2 - t1) * ((2 / 3) - t3) * 6
+							: t1;
+			}
+			return c;
+		},
+
+		'rgb-gray': function(r, g, b) {
+			return [r * 0.2989 + g * 0.587 + b * 0.114];
+		},
+
+		'gray-rgb': function(g) {
+			return [g, g, g];
+		},
+
+		'gray-hsb': function(g) {
+			return [0, 0, g];
+		},
+
+		'gray-hsl': function(g) {
+			return [0, 0, g];
+		},
+
+		'gradient-rgb': function() {
+			return [];
+		},
+
+		'rgb-gradient': function() {
+			return [];
+		}
+
+	};
+
+	return Base.each(types, function(properties, type) {
+		componentParsers[type] = [];
+		Base.each(properties, function(name, index) {
+			var part = Base.capitalize(name),
+				hasOverlap = /^(hue|saturation)$/.test(name),
+				parser = componentParsers[type][index] = type === 'gradient'
+					? name === 'gradient'
+						? function(value) {
+							var current = this._components[0];
+							value = Gradient.read(
+								Array.isArray(value)
+									? value
+									: arguments, 0, { readNull: true }
+							);
+							if (current !== value) {
+								if (current)
+									current._removeOwner(this);
+								if (value)
+									value._addOwner(this);
+							}
+							return value;
+						}
+						: function() {
+							return Point.read(arguments, 0, {
+									readNull: name === 'highlight',
+									clone: true
+							});
+						}
+					: function(value) {
+						return value == null || isNaN(value) ? 0 : +value;
+					};
+			this['get' + part] = function() {
+				return this._type === type
+					|| hasOverlap && /^hs[bl]$/.test(this._type)
+						? this._components[index]
+						: this._convert(type)[index];
+			};
+
+			this['set' + part] = function(value) {
+				if (this._type !== type
+						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
+					this._components = this._convert(type);
+					this._properties = types[type];
+					this._type = type;
+				}
+				this._components[index] = parser.call(this, value);
+				this._changed();
+			};
+		}, this);
+	}, {
+		_class: 'Color',
+		_readIndex: true,
+
+		initialize: function Color(arg) {
+			var args = arguments,
+				reading = this.__read,
+				read = 0,
+				type,
+				components,
+				alpha,
+				values;
+			if (Array.isArray(arg)) {
+				args = arg;
+				arg = args[0];
+			}
+			var argType = arg != null && typeof arg;
+			if (argType === 'string' && arg in types) {
+				type = arg;
+				arg = args[1];
+				if (Array.isArray(arg)) {
+					components = arg;
+					alpha = args[2];
+				} else {
+					if (reading)
+						read = 1;
+					args = Base.slice(args, 1);
+					argType = typeof arg;
+				}
+			}
+			if (!components) {
+				values = argType === 'number'
+						? args
+						: argType === 'object' && arg.length != null
+							? arg
+							: null;
+				if (values) {
+					if (!type)
+						type = values.length >= 3
+								? 'rgb'
+								: 'gray';
+					var length = types[type].length;
+					alpha = values[length];
+					if (reading) {
+						read += values === arguments
+							? length + (alpha != null ? 1 : 0)
+							: 1;
+					}
+					if (values.length > length)
+						values = Base.slice(values, 0, length);
+				} else if (argType === 'string') {
+					var converted = fromCSS(arg);
+					type = converted[0];
+					components = converted[1];
+					if (components.length === 4) {
+						alpha = components[3];
+						components.length--;
+					}
+				} else if (argType === 'object') {
+					if (arg.constructor === Color) {
+						type = arg._type;
+						components = arg._components.slice();
+						alpha = arg._alpha;
+						if (type === 'gradient') {
+							for (var i = 1, l = components.length; i < l; i++) {
+								var point = components[i];
+								if (point)
+									components[i] = point.clone();
+							}
+						}
+					} else if (arg.constructor === Gradient) {
+						type = 'gradient';
+						values = args;
+					} else {
+						type = 'hue' in arg
+							? 'lightness' in arg
+								? 'hsl'
+								: 'hsb'
+							: 'gradient' in arg || 'stops' in arg
+									|| 'radial' in arg
+								? 'gradient'
+								: 'gray' in arg
+									? 'gray'
+									: 'rgb';
+						var properties = types[type],
+							parsers = componentParsers[type];
+						this._components = components = [];
+						for (var i = 0, l = properties.length; i < l; i++) {
+							var value = arg[properties[i]];
+							if (value == null && !i && type === 'gradient'
+									&& 'stops' in arg) {
+								value = {
+									stops: arg.stops,
+									radial: arg.radial
+								};
+							}
+							value = parsers[i].call(this, value);
+							if (value != null)
+								components[i] = value;
+						}
+						alpha = arg.alpha;
+					}
+				}
+				if (reading && type)
+					read = 1;
+			}
+			this._type = type || 'rgb';
+			if (!components) {
+				this._components = components = [];
+				var parsers = componentParsers[this._type];
+				for (var i = 0, l = parsers.length; i < l; i++) {
+					var value = parsers[i].call(this, values && values[i]);
+					if (value != null)
+						components[i] = value;
+				}
+			}
+			this._components = components;
+			this._properties = types[this._type];
+			this._alpha = alpha;
+			if (reading)
+				this.__read = read;
+			return this;
+		},
+
+		set: '#initialize',
+
+		_serialize: function(options, dictionary) {
+			var components = this.getComponents();
+			return Base.serialize(
+					/^(gray|rgb)$/.test(this._type)
+						? components
+						: [this._type].concat(components),
+					options, true, dictionary);
+		},
+
+		_changed: function() {
+			this._canvasStyle = null;
+			if (this._owner) {
+				if (this._setter) {
+					this._owner[this._setter](this);
+				} else {
+					this._owner._changed(129);
+				}
+			}
+		},
+
+		_convert: function(type) {
+			var converter;
+			return this._type === type
+					? this._components.slice()
+					: (converter = converters[this._type + '-' + type])
+						? converter.apply(this, this._components)
+						: converters['rgb-' + type].apply(this,
+							converters[this._type + '-rgb'].apply(this,
+								this._components));
+		},
+
+		convert: function(type) {
+			return new Color(type, this._convert(type), this._alpha);
+		},
+
+		getType: function() {
+			return this._type;
+		},
+
+		setType: function(type) {
+			this._components = this._convert(type);
+			this._properties = types[type];
+			this._type = type;
+		},
+
+		getComponents: function() {
+			var components = this._components.slice();
+			if (this._alpha != null)
+				components.push(this._alpha);
+			return components;
+		},
+
+		getAlpha: function() {
+			return this._alpha != null ? this._alpha : 1;
+		},
+
+		setAlpha: function(alpha) {
+			this._alpha = alpha == null ? null : Math.min(Math.max(alpha, 0), 1);
+			this._changed();
+		},
+
+		hasAlpha: function() {
+			return this._alpha != null;
+		},
+
+		equals: function(color) {
+			var col = Base.isPlainValue(color, true)
+					? Color.read(arguments)
+					: color;
+			return col === this || col && this._class === col._class
+					&& this._type === col._type
+					&& this.getAlpha() === col.getAlpha()
+					&& Base.equals(this._components, col._components)
+					|| false;
+		},
+
+		toString: function() {
+			var properties = this._properties,
+				parts = [],
+				isGradient = this._type === 'gradient',
+				f = Formatter.instance;
+			for (var i = 0, l = properties.length; i < l; i++) {
+				var value = this._components[i];
+				if (value != null)
+					parts.push(properties[i] + ': '
+							+ (isGradient ? value : f.number(value)));
+			}
+			if (this._alpha != null)
+				parts.push('alpha: ' + f.number(this._alpha));
+			return '{ ' + parts.join(', ') + ' }';
+		},
+
+		toCSS: function(hex) {
+			var components = this._convert('rgb'),
+				alpha = hex || this._alpha == null ? 1 : this._alpha;
+			function convert(val) {
+				return Math.round((val < 0 ? 0 : val > 1 ? 1 : val) * 255);
+			}
+			components = [
+				convert(components[0]),
+				convert(components[1]),
+				convert(components[2])
+			];
+			if (alpha < 1)
+				components.push(alpha < 0 ? 0 : alpha);
+			return hex
+					? '#' + ((1 << 24) + (components[0] << 16)
+						+ (components[1] << 8)
+						+ components[2]).toString(16).slice(1)
+					: (components.length == 4 ? 'rgba(' : 'rgb(')
+						+ components.join(',') + ')';
+		},
+
+		toCanvasStyle: function(ctx, matrix) {
+			if (this._canvasStyle)
+				return this._canvasStyle;
+			if (this._type !== 'gradient')
+				return this._canvasStyle = this.toCSS();
+			var components = this._components,
+				gradient = components[0],
+				stops = gradient._stops,
+				origin = components[1],
+				destination = components[2],
+				highlight = components[3],
+				inverse = matrix && matrix.inverted(),
+				canvasGradient;
+			if (inverse) {
+				origin = inverse._transformPoint(origin);
+				destination = inverse._transformPoint(destination);
+				if (highlight)
+					highlight = inverse._transformPoint(highlight);
+			}
+			if (gradient._radial) {
+				var radius = destination.getDistance(origin);
+				if (highlight) {
+					var vector = highlight.subtract(origin);
+					if (vector.getLength() > radius)
+						highlight = origin.add(vector.normalize(radius - 0.1));
+				}
+				var start = highlight || origin;
+				canvasGradient = ctx.createRadialGradient(start.x, start.y,
+						0, origin.x, origin.y, radius);
+			} else {
+				canvasGradient = ctx.createLinearGradient(origin.x, origin.y,
+						destination.x, destination.y);
+			}
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					offset = stop._offset;
+				canvasGradient.addColorStop(
+						offset == null ? i / (l - 1) : offset,
+						stop._color.toCanvasStyle());
+			}
+			return this._canvasStyle = canvasGradient;
+		},
+
+		transform: function(matrix) {
+			if (this._type === 'gradient') {
+				var components = this._components;
+				for (var i = 1, l = components.length; i < l; i++) {
+					var point = components[i];
+					matrix._transformPoint(point, point, true);
+				}
+				this._changed();
+			}
+		},
+
+		statics: {
+			_types: types,
+
+			random: function() {
+				var random = Math.random;
+				return new Color(random(), random(), random());
+			},
+
+			_setOwner: function(color, owner, setter) {
+				if (color) {
+					if (color._owner && owner && color._owner !== owner) {
+						color = color.clone();
+					}
+					if (!color._owner ^ !owner) {
+						color._owner = owner || null;
+						color._setter = setter || null;
+					}
+				}
+				return color;
+			}
+		}
+	});
+},
+new function() {
+	var operators = {
+		add: function(a, b) {
+			return a + b;
+		},
+
+		subtract: function(a, b) {
+			return a - b;
+		},
+
+		multiply: function(a, b) {
+			return a * b;
+		},
+
+		divide: function(a, b) {
+			return a / b;
+		}
+	};
+
+	return Base.each(operators, function(operator, name) {
+		this[name] = function(color) {
+			color = Color.read(arguments);
+			var type = this._type,
+				components1 = this._components,
+				components2 = color._convert(type);
+			for (var i = 0, l = components1.length; i < l; i++)
+				components2[i] = operator(components1[i], components2[i]);
+			return new Color(type, components2,
+					this._alpha != null
+							? operator(this._alpha, color.getAlpha())
+							: null);
+		};
+	}, {
+	});
+});
+
+var Gradient = Base.extend({
+	_class: 'Gradient',
+
+	initialize: function Gradient(stops, radial) {
+		this._id = UID.get();
+		if (stops && Base.isPlainObject(stops)) {
+			this.set(stops);
+			stops = radial = null;
+		}
+		if (this._stops == null) {
+			this.setStops(stops || ['white', 'black']);
+		}
+		if (this._radial == null) {
+			this.setRadial(typeof radial === 'string' && radial === 'radial'
+					|| radial || false);
+		}
+	},
+
+	_serialize: function(options, dictionary) {
+		return dictionary.add(this, function() {
+			return Base.serialize([this._stops, this._radial],
+					options, true, dictionary);
+		});
+	},
+
+	_changed: function() {
+		for (var i = 0, l = this._owners && this._owners.length; i < l; i++) {
+			this._owners[i]._changed();
+		}
+	},
+
+	_addOwner: function(color) {
+		if (!this._owners)
+			this._owners = [];
+		this._owners.push(color);
+	},
+
+	_removeOwner: function(color) {
+		var index = this._owners ? this._owners.indexOf(color) : -1;
+		if (index != -1) {
+			this._owners.splice(index, 1);
+			if (!this._owners.length)
+				this._owners = undefined;
+		}
+	},
+
+	clone: function() {
+		var stops = [];
+		for (var i = 0, l = this._stops.length; i < l; i++) {
+			stops[i] = this._stops[i].clone();
+		}
+		return new Gradient(stops, this._radial);
+	},
+
+	getStops: function() {
+		return this._stops;
+	},
+
+	setStops: function(stops) {
+		if (stops.length < 2) {
+			throw new Error(
+					'Gradient stop list needs to contain at least two stops.');
+		}
+		var _stops = this._stops;
+		if (_stops) {
+			for (var i = 0, l = _stops.length; i < l; i++)
+				_stops[i]._owner = undefined;
+		}
+		_stops = this._stops = GradientStop.readList(stops, 0, { clone: true });
+		for (var i = 0, l = _stops.length; i < l; i++)
+			_stops[i]._owner = this;
+		this._changed();
+	},
+
+	getRadial: function() {
+		return this._radial;
+	},
+
+	setRadial: function(radial) {
+		this._radial = radial;
+		this._changed();
+	},
+
+	equals: function(gradient) {
+		if (gradient === this)
+			return true;
+		if (gradient && this._class === gradient._class) {
+			var stops1 = this._stops,
+				stops2 = gradient._stops,
+				length = stops1.length;
+			if (length === stops2.length) {
+				for (var i = 0; i < length; i++) {
+					if (!stops1[i].equals(stops2[i]))
+						return false;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+var GradientStop = Base.extend({
+	_class: 'GradientStop',
+
+	initialize: function GradientStop(arg0, arg1) {
+		var color = arg0,
+			offset = arg1;
+		if (typeof arg0 === 'object' && arg1 === undefined) {
+			if (Array.isArray(arg0) && typeof arg0[0] !== 'number') {
+				color = arg0[0];
+				offset = arg0[1];
+			} else if ('color' in arg0 || 'offset' in arg0
+					|| 'rampPoint' in arg0) {
+				color = arg0.color;
+				offset = arg0.offset || arg0.rampPoint || 0;
+			}
+		}
+		this.setColor(color);
+		this.setOffset(offset);
+	},
+
+	clone: function() {
+		return new GradientStop(this._color.clone(), this._offset);
+	},
+
+	_serialize: function(options, dictionary) {
+		var color = this._color,
+			offset = this._offset;
+		return Base.serialize(offset == null ? [color] : [color, offset],
+				options, true, dictionary);
+	},
+
+	_changed: function() {
+		if (this._owner)
+			this._owner._changed(129);
+	},
+
+	getOffset: function() {
+		return this._offset;
+	},
+
+	setOffset: function(offset) {
+		this._offset = offset;
+		this._changed();
+	},
+
+	getRampPoint: '#getOffset',
+	setRampPoint: '#setOffset',
+
+	getColor: function() {
+		return this._color;
+	},
+
+	setColor: function() {
+		Color._setOwner(this._color, null);
+		this._color = Color._setOwner(Color.read(arguments, 0), this,
+				'setColor');
+		this._changed();
+	},
+
+	equals: function(stop) {
+		return stop === this || stop && this._class === stop._class
+				&& this._color.equals(stop._color)
+				&& this._offset == stop._offset
+				|| false;
+	}
+});
+
+var Style = Base.extend(new function() {
+	var itemDefaults = {
+		fillColor: null,
+		fillRule: 'nonzero',
+		strokeColor: null,
+		strokeWidth: 1,
+		strokeCap: 'butt',
+		strokeJoin: 'miter',
+		strokeScaling: true,
+		miterLimit: 10,
+		dashOffset: 0,
+		dashArray: [],
+		shadowColor: null,
+		shadowBlur: 0,
+		shadowOffset: new Point(),
+		selectedColor: null
+	},
+	groupDefaults = Base.set({}, itemDefaults, {
+		fontFamily: 'sans-serif',
+		fontWeight: 'normal',
+		fontSize: 12,
+		leading: null,
+		justification: 'left'
+	}),
+	textDefaults = Base.set({}, groupDefaults, {
+		fillColor: new Color()
+	}),
+	flags = {
+		strokeWidth: 193,
+		strokeCap: 193,
+		strokeJoin: 193,
+		strokeScaling: 201,
+		miterLimit: 193,
+		fontFamily: 9,
+		fontWeight: 9,
+		fontSize: 9,
+		font: 9,
+		leading: 9,
+		justification: 9
+	},
+	item = {
+		beans: true
+	},
+	fields = {
+		_class: 'Style',
+		beans: true,
+
+		initialize: function Style(style, _owner, _project) {
+			this._values = {};
+			this._owner = _owner;
+			this._project = _owner && _owner._project || _project
+					|| paper.project;
+			this._defaults = !_owner || _owner instanceof Group ? groupDefaults
+					: _owner instanceof TextItem ? textDefaults
+					: itemDefaults;
+			if (style)
+				this.set(style);
+		}
+	};
+
+	Base.each(groupDefaults, function(value, key) {
+		var isColor = /Color$/.test(key),
+			isPoint = key === 'shadowOffset',
+			part = Base.capitalize(key),
+			flag = flags[key],
+			set = 'set' + part,
+			get = 'get' + part;
+
+		fields[set] = function(value) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath);
+			if (applyToChildren) {
+				for (var i = 0, l = children.length; i < l; i++)
+					children[i]._style[set](value);
+			}
+			if ((key === 'selectedColor' || !applyToChildren)
+					&& key in this._defaults) {
+				var old = this._values[key];
+				if (old !== value) {
+					if (isColor) {
+						if (old) {
+							Color._setOwner(old, null);
+							old._canvasStyle = null;
+						}
+						if (value && value.constructor === Color) {
+							value = Color._setOwner(value, owner,
+									applyToChildren && set);
+						}
+					}
+					this._values[key] = value;
+					if (owner)
+						owner._changed(flag || 129);
+				}
+			}
+		};
+
+		fields[get] = function(_dontMerge) {
+			var owner = this._owner,
+				children = owner && owner._children,
+				applyToChildren = children && children.length > 0
+					&& !(owner instanceof CompoundPath),
+				value;
+			if (applyToChildren && !_dontMerge) {
+				for (var i = 0, l = children.length; i < l; i++) {
+					var childValue = children[i]._style[get]();
+					if (!i) {
+						value = childValue;
+					} else if (!Base.equals(value, childValue)) {
+						return undefined;
+					}
+				}
+			} else if (key in this._defaults) {
+				var value = this._values[key];
+				if (value === undefined) {
+					value = this._defaults[key];
+					if (value && value.clone) {
+						value = value.clone();
+					}
+				} else {
+					var ctor = isColor ? Color : isPoint ? Point : null;
+					if (ctor && !(value && value.constructor === ctor)) {
+						this._values[key] = value = ctor.read([value], 0,
+								{ readNull: true, clone: true });
+					}
+				}
+			}
+			if (value && isColor) {
+				value = Color._setOwner(value, owner, applyToChildren && set);
+			}
+			return value;
+		};
+
+		item[get] = function(_dontMerge) {
+			return this._style[get](_dontMerge);
+		};
+
+		item[set] = function(value) {
+			this._style[set](value);
+		};
+	});
+
+	Base.each({
+		Font: 'FontFamily',
+		WindingRule: 'FillRule'
+	}, function(value, key) {
+		var get = 'get' + key,
+			set = 'set' + key;
+		fields[get] = item[get] = '#get' + value;
+		fields[set] = item[set] = '#set' + value;
+	});
+
+	Item.inject(item);
+	return fields;
+}, {
+	set: function(style) {
+		var isStyle = style instanceof Style,
+			values = isStyle ? style._values : style;
+		if (values) {
+			for (var key in values) {
+				if (key in this._defaults) {
+					var value = values[key];
+					this[key] = value && isStyle && value.clone
+							? value.clone() : value;
+				}
+			}
+		}
+	},
+
+	equals: function(style) {
+		function compare(style1, style2, secondary) {
+			var values1 = style1._values,
+				values2 = style2._values,
+				defaults2 = style2._defaults;
+			for (var key in values1) {
+				var value1 = values1[key],
+					value2 = values2[key];
+				if (!(secondary && key in values2) && !Base.equals(value1,
+						value2 === undefined ? defaults2[key] : value2))
+					return false;
+			}
+			return true;
+		}
+
+		return style === this || style && this._class === style._class
+				&& compare(this, style)
+				&& compare(style, this, true)
+				|| false;
+	},
+
+	_dispose: function() {
+		var color;
+		color = this.getFillColor();
+		if (color) color._canvasStyle = null;
+		color = this.getStrokeColor();
+		if (color) color._canvasStyle = null;
+		color = this.getShadowColor();
+		if (color) color._canvasStyle = null;
+	},
+
+	hasFill: function() {
+		var color = this.getFillColor();
+		return !!color && color.alpha > 0;
+	},
+
+	hasStroke: function() {
+		var color = this.getStrokeColor();
+		return !!color && color.alpha > 0 && this.getStrokeWidth() > 0;
+	},
+
+	hasShadow: function() {
+		var color = this.getShadowColor();
+		return !!color && color.alpha > 0 && (this.getShadowBlur() > 0
+				|| !this.getShadowOffset().isZero());
+	},
+
+	getView: function() {
+		return this._project._view;
+	},
+
+	getFontStyle: function() {
+		var fontSize = this.getFontSize();
+		return this.getFontWeight()
+				+ ' ' + fontSize + (/[a-z]/i.test(fontSize + '') ? ' ' : 'px ')
+				+ this.getFontFamily();
+	},
+
+	getFont: '#getFontFamily',
+	setFont: '#setFontFamily',
+
+	getLeading: function getLeading() {
+		var leading = getLeading.base.call(this),
+			fontSize = this.getFontSize();
+		if (/pt|em|%|px/.test(fontSize))
+			fontSize = this.getView().getPixelSize(fontSize);
+		return leading != null ? leading : fontSize * 1.2;
+	}
+
+});
+
+var DomElement = new function() {
+	function handlePrefix(el, name, set, value) {
+		var prefixes = ['', 'webkit', 'moz', 'Moz', 'ms', 'o'],
+			suffix = name[0].toUpperCase() + name.substring(1);
+		for (var i = 0; i < 6; i++) {
+			var prefix = prefixes[i],
+				key = prefix ? prefix + suffix : name;
+			if (key in el) {
+				if (set) {
+					el[key] = value;
+				} else {
+					return el[key];
+				}
+				break;
+			}
+		}
+	}
+
+	return {
+		getStyles: function(el) {
+			var doc = el && el.nodeType !== 9 ? el.ownerDocument : el,
+				view = doc && doc.defaultView;
+			return view && view.getComputedStyle(el, '');
+		},
+
+		getBounds: function(el, viewport) {
+			var doc = el.ownerDocument,
+				body = doc.body,
+				html = doc.documentElement,
+				rect;
+			try {
+				rect = el.getBoundingClientRect();
+			} catch (e) {
+				rect = { left: 0, top: 0, width: 0, height: 0 };
+			}
+			var x = rect.left - (html.clientLeft || body.clientLeft || 0),
+				y = rect.top - (html.clientTop || body.clientTop || 0);
+			if (!viewport) {
+				var view = doc.defaultView;
+				x += view.pageXOffset || html.scrollLeft || body.scrollLeft;
+				y += view.pageYOffset || html.scrollTop || body.scrollTop;
+			}
+			return new Rectangle(x, y, rect.width, rect.height);
+		},
+
+		getViewportBounds: function(el) {
+			var doc = el.ownerDocument,
+				view = doc.defaultView,
+				html = doc.documentElement;
+			return new Rectangle(0, 0,
+				view.innerWidth || html.clientWidth,
+				view.innerHeight || html.clientHeight
+			);
+		},
+
+		getOffset: function(el, viewport) {
+			return DomElement.getBounds(el, viewport).getPoint();
+		},
+
+		getSize: function(el) {
+			return DomElement.getBounds(el, true).getSize();
+		},
+
+		isInvisible: function(el) {
+			return DomElement.getSize(el).equals(new Size(0, 0));
+		},
+
+		isInView: function(el) {
+			return !DomElement.isInvisible(el)
+					&& DomElement.getViewportBounds(el).intersects(
+						DomElement.getBounds(el, true));
+		},
+
+		isInserted: function(el) {
+			return document.body.contains(el);
+		},
+
+		getPrefixed: function(el, name) {
+			return el && handlePrefix(el, name);
+		},
+
+		setPrefixed: function(el, name, value) {
+			if (typeof name === 'object') {
+				for (var key in name)
+					handlePrefix(el, key, true, name[key]);
+			} else {
+				handlePrefix(el, name, true, value);
+			}
+		}
+	};
+};
+
+var DomEvent = {
+	add: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++) {
+					var name = parts[i];
+					var options = (
+						el === document
+						&& (name === 'touchstart' || name === 'touchmove')
+					) ? { passive: false } : false;
+					el.addEventListener(name, func, options);
+				}
+			}
+		}
+	},
+
+	remove: function(el, events) {
+		if (el) {
+			for (var type in events) {
+				var func = events[type],
+					parts = type.split(/[\s,]+/g);
+				for (var i = 0, l = parts.length; i < l; i++)
+					el.removeEventListener(parts[i], func, false);
+			}
+		}
+	},
+
+	getPoint: function(event) {
+		var pos = event.targetTouches
+				? event.targetTouches.length
+					? event.targetTouches[0]
+					: event.changedTouches[0]
+				: event;
+		return new Point(
+			pos.pageX || pos.clientX + document.documentElement.scrollLeft,
+			pos.pageY || pos.clientY + document.documentElement.scrollTop
+		);
+	},
+
+	getTarget: function(event) {
+		return event.target || event.srcElement;
+	},
+
+	getRelatedTarget: function(event) {
+		return event.relatedTarget || event.toElement;
+	},
+
+	getOffset: function(event, target) {
+		return DomEvent.getPoint(event).subtract(DomElement.getOffset(
+				target || DomEvent.getTarget(event)));
+	}
+};
+
+DomEvent.requestAnimationFrame = new function() {
+	var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
+		requested = false,
+		callbacks = [],
+		timer;
+
+	function handleCallbacks() {
+		var functions = callbacks;
+		callbacks = [];
+		for (var i = 0, l = functions.length; i < l; i++)
+			functions[i]();
+		requested = nativeRequest && callbacks.length;
+		if (requested)
+			nativeRequest(handleCallbacks);
+	}
+
+	return function(callback) {
+		callbacks.push(callback);
+		if (nativeRequest) {
+			if (!requested) {
+				nativeRequest(handleCallbacks);
+				requested = true;
+			}
+		} else if (!timer) {
+			timer = setInterval(handleCallbacks, 1000 / 60);
+		}
+	};
+};
+
+var View = Base.extend(Emitter, {
+	_class: 'View',
+
+	initialize: function View(project, element) {
+
+		function getSize(name) {
+			return element[name] || parseInt(element.getAttribute(name), 10);
+		}
+
+		function getCanvasSize() {
+			var size = DomElement.getSize(element);
+			return size.isNaN() || size.isZero()
+					? new Size(getSize('width'), getSize('height'))
+					: size;
+		}
+
+		var size;
+		if (window && element) {
+			this._id = element.getAttribute('id');
+			if (this._id == null)
+				element.setAttribute('id', this._id = 'paper-view-' + View._id++);
+			DomEvent.add(element, this._viewEvents);
+			var none = 'none';
+			DomElement.setPrefixed(element.style, {
+				userDrag: none,
+				userSelect: none,
+				touchCallout: none,
+				contentZooming: none,
+				tapHighlightColor: 'rgba(0,0,0,0)'
+			});
+
+			if (PaperScope.hasAttribute(element, 'resize')) {
+				var that = this;
+				DomEvent.add(window, this._windowEvents = {
+					resize: function() {
+						that.setViewSize(getCanvasSize());
+					}
+				});
+			}
+
+			size = getCanvasSize();
+
+			if (PaperScope.hasAttribute(element, 'stats')
+					&& typeof Stats !== 'undefined') {
+				this._stats = new Stats();
+				var stats = this._stats.domElement,
+					style = stats.style,
+					offset = DomElement.getOffset(element);
+				style.position = 'absolute';
+				style.left = offset.x + 'px';
+				style.top = offset.y + 'px';
+				document.body.appendChild(stats);
+			}
+		} else {
+			size = new Size(element);
+			element = null;
+		}
+		this._project = project;
+		this._scope = project._scope;
+		this._element = element;
+		if (!this._pixelRatio)
+			this._pixelRatio = window && window.devicePixelRatio || 1;
+		this._setElementSize(size.width, size.height);
+		this._viewSize = size;
+		View._views.push(this);
+		View._viewsById[this._id] = this;
+		(this._matrix = new Matrix())._owner = this;
+		if (!View._focused)
+			View._focused = this;
+		this._frameItems = {};
+		this._frameItemCount = 0;
+		this._itemEvents = { native: {}, virtual: {} };
+		this._autoUpdate = !paper.agent.node;
+		this._needsUpdate = false;
+	},
+
+	remove: function() {
+		if (!this._project)
+			return false;
+		if (View._focused === this)
+			View._focused = null;
+		View._views.splice(View._views.indexOf(this), 1);
+		delete View._viewsById[this._id];
+		var project = this._project;
+		if (project._view === this)
+			project._view = null;
+		DomEvent.remove(this._element, this._viewEvents);
+		DomEvent.remove(window, this._windowEvents);
+		this._element = this._project = null;
+		this.off('frame');
+		this._animate = false;
+		this._frameItems = {};
+		return true;
+	},
+
+	_events: Base.each(
+		Item._itemHandlers.concat(['onResize', 'onKeyDown', 'onKeyUp']),
+		function(name) {
+			this[name] = {};
+		}, {
+			onFrame: {
+				install: function() {
+					this.play();
+				},
+
+				uninstall: function() {
+					this.pause();
+				}
+			}
+		}
+	),
+
+	_animate: false,
+	_time: 0,
+	_count: 0,
+
+	getAutoUpdate: function() {
+		return this._autoUpdate;
+	},
+
+	setAutoUpdate: function(autoUpdate) {
+		this._autoUpdate = autoUpdate;
+		if (autoUpdate)
+			this.requestUpdate();
+	},
+
+	update: function() {
+	},
+
+	draw: function() {
+		this.update();
+	},
+
+	requestUpdate: function() {
+		if (!this._requested) {
+			var that = this;
+			DomEvent.requestAnimationFrame(function() {
+				that._requested = false;
+				if (that._animate) {
+					that.requestUpdate();
+					var element = that._element;
+					if ((!DomElement.getPrefixed(document, 'hidden')
+							|| PaperScope.getAttribute(element, 'keepalive')
+								=== 'true') && DomElement.isInView(element)) {
+						that._handleFrame();
+					}
+				}
+				if (that._autoUpdate)
+					that.update();
+			});
+			this._requested = true;
+		}
+	},
+
+	play: function() {
+		this._animate = true;
+		this.requestUpdate();
+	},
+
+	pause: function() {
+		this._animate = false;
+	},
+
+	_handleFrame: function() {
+		paper = this._scope;
+		var now = Date.now() / 1000,
+			delta = this._last ? now - this._last : 0;
+		this._last = now;
+		this.emit('frame', new Base({
+			delta: delta,
+			time: this._time += delta,
+			count: this._count++
+		}));
+		if (this._stats)
+			this._stats.update();
+	},
+
+	_animateItem: function(item, animate) {
+		var items = this._frameItems;
+		if (animate) {
+			items[item._id] = {
+				item: item,
+				time: 0,
+				count: 0
+			};
+			if (++this._frameItemCount === 1)
+				this.on('frame', this._handleFrameItems);
+		} else {
+			delete items[item._id];
+			if (--this._frameItemCount === 0) {
+				this.off('frame', this._handleFrameItems);
+			}
+		}
+	},
+
+	_handleFrameItems: function(event) {
+		for (var i in this._frameItems) {
+			var entry = this._frameItems[i];
+			entry.item.emit('frame', new Base(event, {
+				time: entry.time += event.delta,
+				count: entry.count++
+			}));
+		}
+	},
+
+	_changed: function() {
+		this._project._changed(4097);
+		this._bounds = this._decomposed = undefined;
+	},
+
+	getElement: function() {
+		return this._element;
+	},
+
+	getPixelRatio: function() {
+		return this._pixelRatio;
+	},
+
+	getResolution: function() {
+		return this._pixelRatio * 72;
+	},
+
+	getViewSize: function() {
+		var size = this._viewSize;
+		return new LinkedSize(size.width, size.height, this, 'setViewSize');
+	},
+
+	setViewSize: function() {
+		var size = Size.read(arguments),
+			delta = size.subtract(this._viewSize);
+		if (delta.isZero())
+			return;
+		this._setElementSize(size.width, size.height);
+		this._viewSize.set(size);
+		this._changed();
+		this.emit('resize', { size: size, delta: delta });
+		if (this._autoUpdate) {
+			this.update();
+		}
+	},
+
+	_setElementSize: function(width, height) {
+		var element = this._element;
+		if (element) {
+			if (element.width !== width)
+				element.width = width;
+			if (element.height !== height)
+				element.height = height;
+		}
+	},
+
+	getBounds: function() {
+		if (!this._bounds)
+			this._bounds = this._matrix.inverted()._transformBounds(
+					new Rectangle(new Point(), this._viewSize));
+		return this._bounds;
+	},
+
+	getSize: function() {
+		return this.getBounds().getSize();
+	},
+
+	isVisible: function() {
+		return DomElement.isInView(this._element);
+	},
+
+	isInserted: function() {
+		return DomElement.isInserted(this._element);
+	},
+
+	getPixelSize: function(size) {
+		var element = this._element,
+			pixels;
+		if (element) {
+			var parent = element.parentNode,
+				temp = document.createElement('div');
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} else {
+			pixels = parseFloat(pixels);
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		return 0;
+	}
+}, Base.each(['rotate', 'scale', 'shear', 'skew'], function(key) {
+	var rotate = key === 'rotate';
+	this[key] = function() {
+		var args = arguments,
+			value = (rotate ? Base : Point).read(args),
+			center = Point.read(args, 0, { readNull: true });
+		return this.transform(new Matrix()[key](value,
+				center || this.getCenter(true)));
+	};
+}, {
+	_decompose: function() {
+		return this._decomposed || (this._decomposed = this._matrix.decompose());
+	},
+
+	translate: function() {
+		var mx = new Matrix();
+		return this.transform(mx.translate.apply(mx, arguments));
+	},
+
+	getCenter: function() {
+		return this.getBounds().getCenter();
+	},
+
+	setCenter: function() {
+		var center = Point.read(arguments);
+		this.translate(this.getCenter().subtract(center));
+	},
+
+	getZoom: function() {
+		var scaling = this._decompose().scaling;
+		return (scaling.x + scaling.y) / 2;
+	},
+
+	setZoom: function(zoom) {
+		this.transform(new Matrix().scale(zoom / this.getZoom(),
+			this.getCenter()));
+	},
+
+	getRotation: function() {
+		return this._decompose().rotation;
+	},
+
+	setRotation: function(rotation) {
+		var current = this.getRotation();
+		if (current != null && rotation != null) {
+			this.rotate(rotation - current);
+		}
+	},
+
+	getScaling: function() {
+		var scaling = this._decompose().scaling;
+		return new LinkedPoint(scaling.x, scaling.y, this, 'setScaling');
+	},
+
+	setScaling: function() {
+		var current = this.getScaling(),
+			scaling = Point.read(arguments, 0, { clone: true, readNull: true });
+		if (current && scaling) {
+			this.scale(scaling.x / current.x, scaling.y / current.y);
+		}
+	},
+
+	getMatrix: function() {
+		return this._matrix;
+	},
+
+	setMatrix: function() {
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
+	},
+
+	transform: function(matrix) {
+		this._matrix.append(matrix);
+	},
+
+	scrollBy: function() {
+		this.translate(Point.read(arguments).negate());
+	}
+}), {
+
+	projectToView: function() {
+		return this._matrix._transformPoint(Point.read(arguments));
+	},
+
+	viewToProject: function() {
+		return this._matrix._inverseTransform(Point.read(arguments));
+	},
+
+	getEventPoint: function(event) {
+		return this.viewToProject(DomEvent.getOffset(event, this._element));
+	},
+
+}, {
+	statics: {
+		_views: [],
+		_viewsById: {},
+		_id: 0,
+
+		create: function(project, element) {
+			if (document && typeof element === 'string')
+				element = document.getElementById(element);
+			var ctor = window ? CanvasView : View;
+			return new ctor(project, element);
+		}
+	}
+},
+new function() {
+	if (!window)
+		return;
+	var prevFocus,
+		tempFocus,
+		dragging = false,
+		mouseDown = false;
+
+	function getView(event) {
+		var target = DomEvent.getTarget(event);
+		return target.getAttribute && View._viewsById[
+				target.getAttribute('id')];
+	}
+
+	function updateFocus() {
+		var view = View._focused;
+		if (!view || !view.isVisible()) {
+			for (var i = 0, l = View._views.length; i < l; i++) {
+				if ((view = View._views[i]).isVisible()) {
+					View._focused = tempFocus = view;
+					break;
+				}
+			}
+		}
+	}
+
+	function handleMouseMove(view, event, point) {
+		view._handleMouseEvent('mousemove', event, point);
+	}
+
+	var navigator = window.navigator,
+		mousedown, mousemove, mouseup;
+	if (navigator.pointerEnabled || navigator.msPointerEnabled) {
+		mousedown = 'pointerdown MSPointerDown';
+		mousemove = 'pointermove MSPointerMove';
+		mouseup = 'pointerup pointercancel MSPointerUp MSPointerCancel';
+	} else {
+		mousedown = 'touchstart';
+		mousemove = 'touchmove';
+		mouseup = 'touchend touchcancel';
+		if (!('ontouchstart' in window && navigator.userAgent.match(
+				/mobile|tablet|ip(ad|hone|od)|android|silk/i))) {
+			mousedown += ' mousedown';
+			mousemove += ' mousemove';
+			mouseup += ' mouseup';
+		}
+	}
+
+	var viewEvents = {},
+		docEvents = {
+			mouseout: function(event) {
+				var view = View._focused,
+					target = DomEvent.getRelatedTarget(event);
+				if (view && (!target || target.nodeName === 'HTML')) {
+					var offset = DomEvent.getOffset(event, view._element),
+						x = offset.x,
+						abs = Math.abs,
+						ax = abs(x),
+						max = 1 << 25,
+						diff = ax - max;
+					offset.x = abs(diff) < ax ? diff * (x < 0 ? -1 : 1) : x;
+					handleMouseMove(view, event, view.viewToProject(offset));
+				}
+			},
+
+			scroll: updateFocus
+		};
+
+	viewEvents[mousedown] = function(event) {
+		var view = View._focused = getView(event);
+		if (!dragging) {
+			dragging = true;
+			view._handleMouseEvent('mousedown', event);
+		}
+	};
+
+	docEvents[mousemove] = function(event) {
+		var view = View._focused;
+		if (!mouseDown) {
+			var target = getView(event);
+			if (target) {
+				if (view !== target) {
+					if (view)
+						handleMouseMove(view, event);
+					if (!prevFocus)
+						prevFocus = view;
+					view = View._focused = tempFocus = target;
+				}
+			} else if (tempFocus && tempFocus === view) {
+				if (prevFocus && !prevFocus.isInserted())
+					prevFocus = null;
+				view = View._focused = prevFocus;
+				prevFocus = null;
+				updateFocus();
+			}
+		}
+		if (view)
+			handleMouseMove(view, event);
+	};
+
+	docEvents[mousedown] = function() {
+		mouseDown = true;
+	};
+
+	docEvents[mouseup] = function(event) {
+		var view = View._focused;
+		if (view && dragging)
+			view._handleMouseEvent('mouseup', event);
+		mouseDown = dragging = false;
+	};
+
+	DomEvent.add(document, docEvents);
+
+	DomEvent.add(window, {
+		load: updateFocus
+	});
+
+	var called = false,
+		prevented = false,
+		fallbacks = {
+			doubleclick: 'click',
+			mousedrag: 'mousemove'
+		},
+		wasInView = false,
+		overView,
+		downPoint,
+		lastPoint,
+		downItem,
+		overItem,
+		dragItem,
+		clickItem,
+		clickTime,
+		dblClick;
+
+	function emitMouseEvent(obj, target, type, event, point, prevPoint,
+			stopItem) {
+		var stopped = false,
+			mouseEvent;
+
+		function emit(obj, type) {
+			if (obj.responds(type)) {
+				if (!mouseEvent) {
+					mouseEvent = new MouseEvent(type, event, point,
+							target || obj,
+							prevPoint ? point.subtract(prevPoint) : null);
+				}
+				if (obj.emit(type, mouseEvent)) {
+					called = true;
+					if (mouseEvent.prevented)
+						prevented = true;
+					if (mouseEvent.stopped)
+						return stopped = true;
+				}
+			} else {
+				var fallback = fallbacks[type];
+				if (fallback)
+					return emit(obj, fallback);
+			}
+		}
+
+		while (obj && obj !== stopItem) {
+			if (emit(obj, type))
+				break;
+			obj = obj._parent;
+		}
+		return stopped;
+	}
+
+	function emitMouseEvents(view, hitItem, type, event, point, prevPoint) {
+		view._project.removeOn(type);
+		prevented = called = false;
+		return (dragItem && emitMouseEvent(dragItem, null, type, event,
+					point, prevPoint)
+			|| hitItem && hitItem !== dragItem
+				&& !hitItem.isDescendant(dragItem)
+				&& emitMouseEvent(hitItem, null, type === 'mousedrag' ?
+					'mousemove' : type, event, point, prevPoint, dragItem)
+			|| emitMouseEvent(view, dragItem || hitItem || view, type, event,
+					point, prevPoint));
+	}
+
+	var itemEventsMap = {
+		mousedown: {
+			mousedown: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mouseup: {
+			mouseup: 1,
+			mousedrag: 1,
+			click: 1,
+			doubleclick: 1
+		},
+		mousemove: {
+			mousedrag: 1,
+			mousemove: 1,
+			mouseenter: 1,
+			mouseleave: 1
+		}
+	};
+
+	return {
+		_viewEvents: viewEvents,
+
+		_handleMouseEvent: function(type, event, point) {
+			var itemEvents = this._itemEvents,
+				hitItems = itemEvents.native[type],
+				nativeMove = type === 'mousemove',
+				tool = this._scope.tool,
+				view = this;
+
+			function responds(type) {
+				return itemEvents.virtual[type] || view.responds(type)
+						|| tool && tool.responds(type);
+			}
+
+			if (nativeMove && dragging && responds('mousedrag'))
+				type = 'mousedrag';
+			if (!point)
+				point = this.getEventPoint(event);
+
+			var inView = this.getBounds().contains(point),
+				hit = hitItems && inView && view._project.hitTest(point, {
+					tolerance: 0,
+					fill: true,
+					stroke: true
+				}),
+				hitItem = hit && hit.item || null,
+				handle = false,
+				mouse = {};
+			mouse[type.substr(5)] = true;
+
+			if (hitItems && hitItem !== overItem) {
+				if (overItem) {
+					emitMouseEvent(overItem, null, 'mouseleave', event, point);
+				}
+				if (hitItem) {
+					emitMouseEvent(hitItem, null, 'mouseenter', event, point);
+				}
+				overItem = hitItem;
+			}
+			if (wasInView ^ inView) {
+				emitMouseEvent(this, null, inView ? 'mouseenter' : 'mouseleave',
+						event, point);
+				overView = inView ? this : null;
+				handle = true;
+			}
+			if ((inView || mouse.drag) && !point.equals(lastPoint)) {
+				emitMouseEvents(this, hitItem, nativeMove ? type : 'mousemove',
+						event, point, lastPoint);
+				handle = true;
+			}
+			wasInView = inView;
+			if (mouse.down && inView || mouse.up && downPoint) {
+				emitMouseEvents(this, hitItem, type, event, point, downPoint);
+				if (mouse.down) {
+					dblClick = hitItem === clickItem
+						&& (Date.now() - clickTime < 300);
+					downItem = clickItem = hitItem;
+					if (!prevented && hitItem) {
+						var item = hitItem;
+						while (item && !item.responds('mousedrag'))
+							item = item._parent;
+						if (item)
+							dragItem = hitItem;
+					}
+					downPoint = point;
+				} else if (mouse.up) {
+					if (!prevented && hitItem === downItem) {
+						clickTime = Date.now();
+						emitMouseEvents(this, hitItem, dblClick ? 'doubleclick'
+								: 'click', event, point, downPoint);
+						dblClick = false;
+					}
+					downItem = dragItem = null;
+				}
+				wasInView = false;
+				handle = true;
+			}
+			lastPoint = point;
+			if (handle && tool) {
+				called = tool._handleMouseEvent(type, event, point, mouse)
+					|| called;
+			}
+
+			if (
+				event.cancelable !== false
+				&& (called && !mouse.move || mouse.down && responds('mouseup'))
+			) {
+				event.preventDefault();
+			}
+		},
+
+		_handleKeyEvent: function(type, event, key, character) {
+			var scope = this._scope,
+				tool = scope.tool,
+				keyEvent;
+
+			function emit(obj) {
+				if (obj.responds(type)) {
+					paper = scope;
+					obj.emit(type, keyEvent = keyEvent
+							|| new KeyEvent(type, event, key, character));
+				}
+			}
+
+			if (this.isVisible()) {
+				emit(this);
+				if (tool && tool.responds(type))
+					emit(tool);
+			}
+		},
+
+		_countItemEvent: function(type, sign) {
+			var itemEvents = this._itemEvents,
+				native = itemEvents.native,
+				virtual = itemEvents.virtual;
+			for (var key in itemEventsMap) {
+				native[key] = (native[key] || 0)
+						+ (itemEventsMap[key][type] || 0) * sign;
+			}
+			virtual[type] = (virtual[type] || 0) + sign;
+		},
+
+		statics: {
+			updateFocus: updateFocus,
+
+			_resetState: function() {
+				dragging = mouseDown = called = wasInView = false;
+				prevFocus = tempFocus = overView = downPoint = lastPoint =
+					downItem = overItem = dragItem = clickItem = clickTime =
+					dblClick = null;
+			}
+		}
+	};
+});
+
+var CanvasView = View.extend({
+	_class: 'CanvasView',
+
+	initialize: function CanvasView(project, canvas) {
+		if (!(canvas instanceof window.HTMLCanvasElement)) {
+			var size = Size.read(arguments, 1);
+			if (size.isZero())
+				throw new Error(
+						'Cannot create CanvasView with the provided argument: '
+						+ Base.slice(arguments, 1));
+			canvas = CanvasProvider.getCanvas(size);
+		}
+		var ctx = this._context = canvas.getContext('2d');
+		ctx.save();
+		this._pixelRatio = 1;
+		if (!/^off|false$/.test(PaperScope.getAttribute(canvas, 'hidpi'))) {
+			var deviceRatio = window.devicePixelRatio || 1,
+				backingStoreRatio = DomElement.getPrefixed(ctx,
+						'backingStorePixelRatio') || 1;
+			this._pixelRatio = deviceRatio / backingStoreRatio;
+		}
+		View.call(this, project, canvas);
+		this._needsUpdate = true;
+	},
+
+	remove: function remove() {
+		this._context.restore();
+		return remove.base.call(this);
+	},
+
+	_setElementSize: function _setElementSize(width, height) {
+		var pixelRatio = this._pixelRatio;
+		_setElementSize.base.call(this, width * pixelRatio, height * pixelRatio);
+		if (pixelRatio !== 1) {
+			var element = this._element,
+				ctx = this._context;
+			if (!PaperScope.hasAttribute(element, 'resize')) {
+				var style = element.style;
+				style.width = width + 'px';
+				style.height = height + 'px';
+			}
+			ctx.restore();
+			ctx.save();
+			ctx.scale(pixelRatio, pixelRatio);
+		}
+	},
+
+	getContext: function() {
+		return this._context;
+	},
+
+	getPixelSize: function getPixelSize(size) {
+		var agent = paper.agent,
+			pixels;
+		if (agent && agent.firefox) {
+			pixels = getPixelSize.base.call(this, size);
+		} else {
+			var ctx = this._context,
+				prevFont = ctx.font;
+			ctx.font = size + ' serif';
+			pixels = parseFloat(ctx.font);
+			ctx.font = prevFont;
+		}
+		return pixels;
+	},
+
+	getTextWidth: function(font, lines) {
+		var ctx = this._context,
+			prevFont = ctx.font,
+			width = 0;
+		ctx.font = font;
+		for (var i = 0, l = lines.length; i < l; i++)
+			width = Math.max(width, ctx.measureText(lines[i]).width);
+		ctx.font = prevFont;
+		return width;
+	},
+
+	update: function() {
+		if (!this._needsUpdate)
+			return false;
+		var project = this._project,
+			ctx = this._context,
+			size = this._viewSize;
+		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
+		if (project)
+			project.draw(ctx, this._matrix, this._pixelRatio);
+		this._needsUpdate = false;
+		return true;
+	}
+});
+
+var Event = Base.extend({
+	_class: 'Event',
+
+	initialize: function Event(event) {
+		this.event = event;
+		this.type = event && event.type;
+	},
+
+	prevented: false,
+	stopped: false,
+
+	preventDefault: function() {
+		this.prevented = true;
+		this.event.preventDefault();
+	},
+
+	stopPropagation: function() {
+		this.stopped = true;
+		this.event.stopPropagation();
+	},
+
+	stop: function() {
+		this.stopPropagation();
+		this.preventDefault();
+	},
+
+	getTimeStamp: function() {
+		return this.event.timeStamp;
+	},
+
+	getModifiers: function() {
+		return Key.modifiers;
+	}
+});
+
+var KeyEvent = Event.extend({
+	_class: 'KeyEvent',
+
+	initialize: function KeyEvent(type, event, key, character) {
+		this.type = type;
+		this.event = event;
+		this.key = key;
+		this.character = character;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', key: '" + this.key
+				+ "', character: '" + this.character
+				+ "', modifiers: " + this.getModifiers()
+				+ " }";
+	}
+});
+
+var Key = new function() {
+	var keyLookup = {
+			'\t': 'tab',
+			' ': 'space',
+			'\b': 'backspace',
+			'\x7f': 'delete',
+			'Spacebar': 'space',
+			'Del': 'delete',
+			'Win': 'meta',
+			'Esc': 'escape'
+		},
+
+		charLookup = {
+			'tab': '\t',
+			'space': ' ',
+			'enter': '\r'
+		},
+
+		keyMap = {},
+		charMap = {},
+		metaFixMap,
+		downKey,
+
+		modifiers = new Base({
+			shift: false,
+			control: false,
+			alt: false,
+			meta: false,
+			capsLock: false,
+			space: false
+		}).inject({
+			option: {
+				get: function() {
+					return this.alt;
+				}
+			},
+
+			command: {
+				get: function() {
+					var agent = paper && paper.agent;
+					return agent && agent.mac ? this.meta : this.control;
+				}
+			}
+		});
+
+	function getKey(event) {
+		var key = event.key || event.keyIdentifier;
+		key = /^U\+/.test(key)
+				? String.fromCharCode(parseInt(key.substr(2), 16))
+				: /^Arrow[A-Z]/.test(key) ? key.substr(5)
+				: key === 'Unidentified'  || key === undefined
+					? String.fromCharCode(event.keyCode)
+					: key;
+		return keyLookup[key] ||
+				(key.length > 1 ? Base.hyphenate(key) : key.toLowerCase());
+	}
+
+	function handleKey(down, key, character, event) {
+		var type = down ? 'keydown' : 'keyup',
+			view = View._focused,
+			name;
+		keyMap[key] = down;
+		if (down) {
+			charMap[key] = character;
+		} else {
+			delete charMap[key];
+		}
+		if (key.length > 1 && (name = Base.camelize(key)) in modifiers) {
+			modifiers[name] = down;
+			var agent = paper && paper.agent;
+			if (name === 'meta' && agent && agent.mac) {
+				if (down) {
+					metaFixMap = {};
+				} else {
+					for (var k in metaFixMap) {
+						if (k in charMap)
+							handleKey(false, k, metaFixMap[k], event);
+					}
+					metaFixMap = null;
+				}
+			}
+		} else if (down && metaFixMap) {
+			metaFixMap[key] = character;
+		}
+		if (view) {
+			view._handleKeyEvent(down ? 'keydown' : 'keyup', event, key,
+					character);
+		}
+	}
+
+	DomEvent.add(document, {
+		keydown: function(event) {
+			var key = getKey(event),
+				agent = paper && paper.agent;
+			if (key.length > 1 || agent && (agent.chrome && (event.altKey
+						|| agent.mac && event.metaKey
+						|| !agent.mac && event.ctrlKey))) {
+				handleKey(true, key,
+						charLookup[key] || (key.length > 1 ? '' : key), event);
+			} else {
+				downKey = key;
+			}
+		},
+
+		keypress: function(event) {
+			if (downKey) {
+				var key = getKey(event),
+					code = event.charCode,
+					character = code >= 32 ? String.fromCharCode(code)
+						: key.length > 1 ? '' : key;
+				if (key !== downKey) {
+					key = character.toLowerCase();
+				}
+				handleKey(true, key, character, event);
+				downKey = null;
+			}
+		},
+
+		keyup: function(event) {
+			var key = getKey(event);
+			if (key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	DomEvent.add(window, {
+		blur: function(event) {
+			for (var key in charMap)
+				handleKey(false, key, charMap[key], event);
+		}
+	});
+
+	return {
+		modifiers: modifiers,
+
+		isDown: function(key) {
+			return !!keyMap[key];
+		}
+	};
+};
+
+var MouseEvent = Event.extend({
+	_class: 'MouseEvent',
+
+	initialize: function MouseEvent(type, event, point, target, delta) {
+		this.type = type;
+		this.event = event;
+		this.point = point;
+		this.target = target;
+		this.delta = delta;
+	},
+
+	toString: function() {
+		return "{ type: '" + this.type
+				+ "', point: " + this.point
+				+ ', target: ' + this.target
+				+ (this.delta ? ', delta: ' + this.delta : '')
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var ToolEvent = Event.extend({
+	_class: 'ToolEvent',
+	_item: null,
+
+	initialize: function ToolEvent(tool, type, event) {
+		this.tool = tool;
+		this.type = type;
+		this.event = event;
+	},
+
+	_choosePoint: function(point, toolPoint) {
+		return point ? point : toolPoint ? toolPoint.clone() : null;
+	},
+
+	getPoint: function() {
+		return this._choosePoint(this._point, this.tool._point);
+	},
+
+	setPoint: function(point) {
+		this._point = point;
+	},
+
+	getLastPoint: function() {
+		return this._choosePoint(this._lastPoint, this.tool._lastPoint);
+	},
+
+	setLastPoint: function(lastPoint) {
+		this._lastPoint = lastPoint;
+	},
+
+	getDownPoint: function() {
+		return this._choosePoint(this._downPoint, this.tool._downPoint);
+	},
+
+	setDownPoint: function(downPoint) {
+		this._downPoint = downPoint;
+	},
+
+	getMiddlePoint: function() {
+		if (!this._middlePoint && this.tool._lastPoint) {
+			return this.tool._point.add(this.tool._lastPoint).divide(2);
+		}
+		return this._middlePoint;
+	},
+
+	setMiddlePoint: function(middlePoint) {
+		this._middlePoint = middlePoint;
+	},
+
+	getDelta: function() {
+		return !this._delta && this.tool._lastPoint
+				? this.tool._point.subtract(this.tool._lastPoint)
+				: this._delta;
+	},
+
+	setDelta: function(delta) {
+		this._delta = delta;
+	},
+
+	getCount: function() {
+		return this.tool[/^mouse(down|up)$/.test(this.type)
+				? '_downCount' : '_moveCount'];
+	},
+
+	setCount: function(count) {
+		this.tool[/^mouse(down|up)$/.test(this.type) ? 'downCount' : 'count']
+			= count;
+	},
+
+	getItem: function() {
+		if (!this._item) {
+			var result = this.tool._scope.project.hitTest(this.getPoint());
+			if (result) {
+				var item = result.item,
+					parent = item._parent;
+				while (/^(Group|CompoundPath)$/.test(parent._class)) {
+					item = parent;
+					parent = parent._parent;
+				}
+				this._item = item;
+			}
+		}
+		return this._item;
+	},
+
+	setItem: function(item) {
+		this._item = item;
+	},
+
+	toString: function() {
+		return '{ type: ' + this.type
+				+ ', point: ' + this.getPoint()
+				+ ', count: ' + this.getCount()
+				+ ', modifiers: ' + this.getModifiers()
+				+ ' }';
+	}
+});
+
+var Tool = PaperScopeItem.extend({
+	_class: 'Tool',
+	_list: 'tools',
+	_reference: 'tool',
+	_events: ['onMouseDown', 'onMouseUp', 'onMouseDrag', 'onMouseMove',
+			'onActivate', 'onDeactivate', 'onEditOptions', 'onKeyDown',
+			'onKeyUp'],
+
+	initialize: function Tool(props) {
+		PaperScopeItem.call(this);
+		this._moveCount = -1;
+		this._downCount = -1;
+		this.set(props);
+	},
+
+	getMinDistance: function() {
+		return this._minDistance;
+	},
+
+	setMinDistance: function(minDistance) {
+		this._minDistance = minDistance;
+		if (minDistance != null && this._maxDistance != null
+				&& minDistance > this._maxDistance) {
+			this._maxDistance = minDistance;
+		}
+	},
+
+	getMaxDistance: function() {
+		return this._maxDistance;
+	},
+
+	setMaxDistance: function(maxDistance) {
+		this._maxDistance = maxDistance;
+		if (this._minDistance != null && maxDistance != null
+				&& maxDistance < this._minDistance) {
+			this._minDistance = maxDistance;
+		}
+	},
+
+	getFixedDistance: function() {
+		return this._minDistance == this._maxDistance
+			? this._minDistance : null;
+	},
+
+	setFixedDistance: function(distance) {
+		this._minDistance = this._maxDistance = distance;
+	},
+
+	_handleMouseEvent: function(type, event, point, mouse) {
+		paper = this._scope;
+		if (mouse.drag && !this.responds(type))
+			type = 'mousemove';
+		var move = mouse.move || mouse.drag,
+			responds = this.responds(type),
+			minDistance = this.minDistance,
+			maxDistance = this.maxDistance,
+			called = false,
+			tool = this;
+		function update(minDistance, maxDistance) {
+			var pt = point,
+				toolPoint = move ? tool._point : (tool._downPoint || pt);
+			if (move) {
+				if (tool._moveCount >= 0 && pt.equals(toolPoint)) {
+					return false;
+				}
+				if (toolPoint && (minDistance != null || maxDistance != null)) {
+					var vector = pt.subtract(toolPoint),
+						distance = vector.getLength();
+					if (distance < (minDistance || 0))
+						return false;
+					if (maxDistance) {
+						pt = toolPoint.add(vector.normalize(
+								Math.min(distance, maxDistance)));
+					}
+				}
+				tool._moveCount++;
+			}
+			tool._point = pt;
+			tool._lastPoint = toolPoint || pt;
+			if (mouse.down) {
+				tool._moveCount = -1;
+				tool._downPoint = pt;
+				tool._downCount++;
+			}
+			return true;
+		}
+
+		function emit() {
+			if (responds) {
+				called = tool.emit(type, new ToolEvent(tool, type, event))
+						|| called;
+			}
+		}
+
+		if (mouse.down) {
+			update();
+			emit();
+		} else if (mouse.up) {
+			update(null, maxDistance);
+			emit();
+		} else if (responds) {
+			while (update(minDistance, maxDistance))
+				emit();
+		}
+		return called;
+	}
+
+});
+
+var Tween = Base.extend(Emitter, {
+	_class: 'Tween',
+
+	statics: {
+		easings: {
+			linear: function(t) {
+				return t;
+			},
+
+			easeInQuad: function(t) {
+				return t * t;
+			},
+
+			easeOutQuad: function(t) {
+				return t * (2 - t);
+			},
+
+			easeInOutQuad: function(t) {
+				return t < 0.5
+					? 2 * t * t
+					: -1 + 2 * (2 - t) * t;
+			},
+
+			easeInCubic: function(t) {
+				return t * t * t;
+			},
+
+			easeOutCubic: function(t) {
+				return --t * t * t + 1;
+			},
+
+			easeInOutCubic: function(t) {
+				return t < 0.5
+					? 4 * t * t * t
+					: (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+			},
+
+			easeInQuart: function(t) {
+				return t * t * t * t;
+			},
+
+			easeOutQuart: function(t) {
+				return 1 - (--t) * t * t * t;
+			},
+
+			easeInOutQuart: function(t) {
+				return t < 0.5
+					? 8 * t * t * t * t
+					: 1 - 8 * (--t) * t * t * t;
+			},
+
+			easeInQuint: function(t) {
+				return t * t * t * t * t;
+			},
+
+			easeOutQuint: function(t) {
+				return 1 + --t * t * t * t * t;
+			},
+
+			easeInOutQuint: function(t) {
+				return t < 0.5
+					? 16 * t * t * t * t * t
+					: 1 + 16 * (--t) * t * t * t * t;
+			}
+		}
+	},
+
+	initialize: function Tween(object, from, to, duration, easing, start) {
+		this.object = object;
+		var type = typeof easing;
+		var isFunction = type === 'function';
+		this.type = isFunction
+			? type
+			: type === 'string'
+				? easing
+				: 'linear';
+		this.easing = isFunction ? easing : Tween.easings[this.type];
+		this.duration = duration;
+		this.running = false;
+
+		this._then = null;
+		this._startTime = null;
+		var state = from || to;
+		this._keys = state ? Object.keys(state) : [];
+		this._parsedKeys = this._parseKeys(this._keys);
+		this._from = state && this._getState(from);
+		this._to = state && this._getState(to);
+		if (start !== false) {
+			this.start();
+		}
+	},
+
+	then: function(then) {
+		this._then = then;
+		return this;
+	},
+
+	start: function() {
+		this._startTime = null;
+		this.running = true;
+		return this;
+	},
+
+	stop: function() {
+		this.running = false;
+		return this;
+	},
+
+	update: function(progress) {
+		if (this.running) {
+			if (progress > 1) {
+				progress = 1;
+				this.running = false;
+			}
+
+			var factor = this.easing(progress),
+				keys = this._keys,
+				getValue = function(value) {
+					return typeof value === 'function'
+						? value(factor, progress)
+						: value;
+				};
+			for (var i = 0, l = keys && keys.length; i < l; i++) {
+				var key = keys[i],
+					from = getValue(this._from[key]),
+					to = getValue(this._to[key]),
+					value = (from && to && from.__add && to.__add)
+						? to.__subtract(from).__multiply(factor).__add(from)
+						: ((to - from) * factor) + from;
+				this._setProperty(this._parsedKeys[key], value);
+			}
+
+			if (!this.running && this._then) {
+				this._then(this.object);
+			}
+			if (this.responds('update')) {
+				this.emit('update', new Base({
+					progress: progress,
+					factor: factor
+				}));
+			}
+		}
+		return this;
+	},
+
+	_events: {
+		onUpdate: {}
+	},
+
+	_handleFrame: function(time) {
+		var startTime = this._startTime,
+			progress = startTime
+				? (time - startTime) / this.duration
+				: 0;
+		if (!startTime) {
+			this._startTime = time;
+		}
+		this.update(progress);
+	},
+
+	_getState: function(state) {
+		var keys = this._keys,
+			result = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = this._parsedKeys[key],
+				current = this._getProperty(path),
+				value;
+			if (state) {
+				var resolved = this._resolveValue(current, state[key]);
+				this._setProperty(path, resolved);
+				value = this._getProperty(path);
+				value = value && value.clone ? value.clone() : value;
+				this._setProperty(path, current);
+			} else {
+				value = current && current.clone ? current.clone() : current;
+			}
+			result[key] = value;
+		}
+		return result;
+	},
+
+	_resolveValue: function(current, value) {
+		if (value) {
+			if (Array.isArray(value) && value.length === 2) {
+				var operator = value[0];
+				return (
+					operator &&
+					operator.match &&
+					operator.match(/^[+\-\*\/]=/)
+				)
+					? this._calculate(current, operator[0], value[1])
+					: value;
+			} else if (typeof value === 'string') {
+				var match = value.match(/^[+\-*/]=(.*)/);
+				if (match) {
+					var parsed = JSON.parse(match[1].replace(
+						/(['"])?([a-zA-Z0-9_]+)(['"])?:/g,
+						'"$2": '
+					));
+					return this._calculate(current, value[0], parsed);
+				}
+			}
+		}
+		return value;
+	},
+
+	_calculate: function(left, operator, right) {
+		return paper.PaperScript.calculateBinary(left, operator, right);
+	},
+
+	_parseKeys: function(keys) {
+		var parsed = {};
+		for (var i = 0, l = keys.length; i < l; i++) {
+			var key = keys[i],
+				path = key
+					.replace(/\.([^.]*)/g, '/$1')
+					.replace(/\[['"]?([^'"\]]*)['"]?\]/g, '/$1');
+			parsed[key] = path.split('/');
+		}
+		return parsed;
+	},
+
+	_getProperty: function(path, offset) {
+		var obj = this.object;
+		for (var i = 0, l = path.length - (offset || 0); i < l && obj; i++) {
+			obj = obj[path[i]];
+		}
+		return obj;
+	},
+
+	_setProperty: function(path, value) {
+		var dest = this._getProperty(path, 1);
+		if (dest) {
+			dest[path[path.length - 1]] = value;
+		}
+	}
+});
+
+var Http = {
+	request: function(options) {
+		var xhr = new self.XMLHttpRequest();
+		xhr.open((options.method || 'get').toUpperCase(), options.url,
+				Base.pick(options.async, true));
+		if (options.mimeType)
+			xhr.overrideMimeType(options.mimeType);
+		xhr.onload = function() {
+			var status = xhr.status;
+			if (status === 0 || status === 200) {
+				if (options.onLoad) {
+					options.onLoad.call(xhr, xhr.responseText);
+				}
+			} else {
+				xhr.onerror();
+			}
+		};
+		xhr.onerror = function() {
+			var status = xhr.status,
+				message = 'Could not load "' + options.url + '" (Status: '
+						+ status + ')';
+			if (options.onError) {
+				options.onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		};
+		return xhr.send(null);
+	}
+};
+
+var CanvasProvider = {
+	canvases: [],
+
+	getCanvas: function(width, height) {
+		if (!window)
+			return null;
+		var canvas,
+			clear = true;
+		if (typeof width === 'object') {
+			height = width.height;
+			width = width.width;
+		}
+		if (this.canvases.length) {
+			canvas = this.canvases.pop();
+		} else {
+			canvas = document.createElement('canvas');
+			clear = false;
+		}
+		var ctx = canvas.getContext('2d');
+		if (!ctx) {
+			throw new Error('Canvas ' + canvas +
+					' is unable to provide a 2D context.');
+		}
+		if (canvas.width === width && canvas.height === height) {
+			if (clear)
+				ctx.clearRect(0, 0, width + 1, height + 1);
+		} else {
+			canvas.width = width;
+			canvas.height = height;
+		}
+		ctx.save();
+		return canvas;
+	},
+
+	getContext: function(width, height) {
+		var canvas = this.getCanvas(width, height);
+		return canvas ? canvas.getContext('2d') : null;
+	},
+
+	release: function(obj) {
+		var canvas = obj && obj.canvas ? obj.canvas : obj;
+		if (canvas && canvas.getContext) {
+			canvas.getContext('2d').restore();
+			this.canvases.push(canvas);
+		}
+	}
+};
+
+var BlendMode = new function() {
+	var min = Math.min,
+		max = Math.max,
+		abs = Math.abs,
+		sr, sg, sb, sa,
+		br, bg, bb, ba,
+		dr, dg, db;
+
+	function getLum(r, g, b) {
+		return 0.2989 * r + 0.587 * g + 0.114 * b;
+	}
+
+	function setLum(r, g, b, l) {
+		var d = l - getLum(r, g, b);
+		dr = r + d;
+		dg = g + d;
+		db = b + d;
+		var l = getLum(dr, dg, db),
+			mn = min(dr, dg, db),
+			mx = max(dr, dg, db);
+		if (mn < 0) {
+			var lmn = l - mn;
+			dr = l + (dr - l) * l / lmn;
+			dg = l + (dg - l) * l / lmn;
+			db = l + (db - l) * l / lmn;
+		}
+		if (mx > 255) {
+			var ln = 255 - l,
+				mxl = mx - l;
+			dr = l + (dr - l) * ln / mxl;
+			dg = l + (dg - l) * ln / mxl;
+			db = l + (db - l) * ln / mxl;
+		}
+	}
+
+	function getSat(r, g, b) {
+		return max(r, g, b) - min(r, g, b);
+	}
+
+	function setSat(r, g, b, s) {
+		var col = [r, g, b],
+			mx = max(r, g, b),
+			mn = min(r, g, b),
+			md;
+		mn = mn === r ? 0 : mn === g ? 1 : 2;
+		mx = mx === r ? 0 : mx === g ? 1 : 2;
+		md = min(mn, mx) === 0 ? max(mn, mx) === 1 ? 2 : 1 : 0;
+		if (col[mx] > col[mn]) {
+			col[md] = (col[md] - col[mn]) * s / (col[mx] - col[mn]);
+			col[mx] = s;
+		} else {
+			col[md] = col[mx] = 0;
+		}
+		col[mn] = 0;
+		dr = col[0];
+		dg = col[1];
+		db = col[2];
+	}
+
+	var modes = {
+		multiply: function() {
+			dr = br * sr / 255;
+			dg = bg * sg / 255;
+			db = bb * sb / 255;
+		},
+
+		screen: function() {
+			dr = br + sr - (br * sr / 255);
+			dg = bg + sg - (bg * sg / 255);
+			db = bb + sb - (bb * sb / 255);
+		},
+
+		overlay: function() {
+			dr = br < 128 ? 2 * br * sr / 255 : 255 - 2 * (255 - br) * (255 - sr) / 255;
+			dg = bg < 128 ? 2 * bg * sg / 255 : 255 - 2 * (255 - bg) * (255 - sg) / 255;
+			db = bb < 128 ? 2 * bb * sb / 255 : 255 - 2 * (255 - bb) * (255 - sb) / 255;
+		},
+
+		'soft-light': function() {
+			var t = sr * br / 255;
+			dr = t + br * (255 - (255 - br) * (255 - sr) / 255 - t) / 255;
+			t = sg * bg / 255;
+			dg = t + bg * (255 - (255 - bg) * (255 - sg) / 255 - t) / 255;
+			t = sb * bb / 255;
+			db = t + bb * (255 - (255 - bb) * (255 - sb) / 255 - t) / 255;
+		},
+
+		'hard-light': function() {
+			dr = sr < 128 ? 2 * sr * br / 255 : 255 - 2 * (255 - sr) * (255 - br) / 255;
+			dg = sg < 128 ? 2 * sg * bg / 255 : 255 - 2 * (255 - sg) * (255 - bg) / 255;
+			db = sb < 128 ? 2 * sb * bb / 255 : 255 - 2 * (255 - sb) * (255 - bb) / 255;
+		},
+
+		'color-dodge': function() {
+			dr = br === 0 ? 0 : sr === 255 ? 255 : min(255, 255 * br / (255 - sr));
+			dg = bg === 0 ? 0 : sg === 255 ? 255 : min(255, 255 * bg / (255 - sg));
+			db = bb === 0 ? 0 : sb === 255 ? 255 : min(255, 255 * bb / (255 - sb));
+		},
+
+		'color-burn': function() {
+			dr = br === 255 ? 255 : sr === 0 ? 0 : max(0, 255 - (255 - br) * 255 / sr);
+			dg = bg === 255 ? 255 : sg === 0 ? 0 : max(0, 255 - (255 - bg) * 255 / sg);
+			db = bb === 255 ? 255 : sb === 0 ? 0 : max(0, 255 - (255 - bb) * 255 / sb);
+		},
+
+		darken: function() {
+			dr = br < sr ? br : sr;
+			dg = bg < sg ? bg : sg;
+			db = bb < sb ? bb : sb;
+		},
+
+		lighten: function() {
+			dr = br > sr ? br : sr;
+			dg = bg > sg ? bg : sg;
+			db = bb > sb ? bb : sb;
+		},
+
+		difference: function() {
+			dr = br - sr;
+			if (dr < 0)
+				dr = -dr;
+			dg = bg - sg;
+			if (dg < 0)
+				dg = -dg;
+			db = bb - sb;
+			if (db < 0)
+				db = -db;
+		},
+
+		exclusion: function() {
+			dr = br + sr * (255 - br - br) / 255;
+			dg = bg + sg * (255 - bg - bg) / 255;
+			db = bb + sb * (255 - bb - bb) / 255;
+		},
+
+		hue: function() {
+			setSat(sr, sg, sb, getSat(br, bg, bb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		saturation: function() {
+			setSat(br, bg, bb, getSat(sr, sg, sb));
+			setLum(dr, dg, db, getLum(br, bg, bb));
+		},
+
+		luminosity: function() {
+			setLum(br, bg, bb, getLum(sr, sg, sb));
+		},
+
+		color: function() {
+			setLum(sr, sg, sb, getLum(br, bg, bb));
+		},
+
+		add: function() {
+			dr = min(br + sr, 255);
+			dg = min(bg + sg, 255);
+			db = min(bb + sb, 255);
+		},
+
+		subtract: function() {
+			dr = max(br - sr, 0);
+			dg = max(bg - sg, 0);
+			db = max(bb - sb, 0);
+		},
+
+		average: function() {
+			dr = (br + sr) / 2;
+			dg = (bg + sg) / 2;
+			db = (bb + sb) / 2;
+		},
+
+		negation: function() {
+			dr = 255 - abs(255 - sr - br);
+			dg = 255 - abs(255 - sg - bg);
+			db = 255 - abs(255 - sb - bb);
+		}
+	};
+
+	var nativeModes = this.nativeModes = Base.each([
+		'source-over', 'source-in', 'source-out', 'source-atop',
+		'destination-over', 'destination-in', 'destination-out',
+		'destination-atop', 'lighter', 'darker', 'copy', 'xor'
+	], function(mode) {
+		this[mode] = true;
+	}, {});
+
+	var ctx = CanvasProvider.getContext(1, 1);
+	if (ctx) {
+		Base.each(modes, function(func, mode) {
+			var darken = mode === 'darken',
+				ok = false;
+			ctx.save();
+			try {
+				ctx.fillStyle = darken ? '#300' : '#a00';
+				ctx.fillRect(0, 0, 1, 1);
+				ctx.globalCompositeOperation = mode;
+				if (ctx.globalCompositeOperation === mode) {
+					ctx.fillStyle = darken ? '#a00' : '#300';
+					ctx.fillRect(0, 0, 1, 1);
+					ok = ctx.getImageData(0, 0, 1, 1).data[0] !== darken
+							? 170 : 51;
+				}
+			} catch (e) {}
+			ctx.restore();
+			nativeModes[mode] = ok;
+		});
+		CanvasProvider.release(ctx);
+	}
+
+	this.process = function(mode, srcContext, dstContext, alpha, offset) {
+		var srcCanvas = srcContext.canvas,
+			normal = mode === 'normal';
+		if (normal || nativeModes[mode]) {
+			dstContext.save();
+			dstContext.setTransform(1, 0, 0, 1, 0, 0);
+			dstContext.globalAlpha = alpha;
+			if (!normal)
+				dstContext.globalCompositeOperation = mode;
+			dstContext.drawImage(srcCanvas, offset.x, offset.y);
+			dstContext.restore();
+		} else {
+			var process = modes[mode];
+			if (!process)
+				return;
+			var dstData = dstContext.getImageData(offset.x, offset.y,
+					srcCanvas.width, srcCanvas.height),
+				dst = dstData.data,
+				src = srcContext.getImageData(0, 0,
+					srcCanvas.width, srcCanvas.height).data;
+			for (var i = 0, l = dst.length; i < l; i += 4) {
+				sr = src[i];
+				br = dst[i];
+				sg = src[i + 1];
+				bg = dst[i + 1];
+				sb = src[i + 2];
+				bb = dst[i + 2];
+				sa = src[i + 3];
+				ba = dst[i + 3];
+				process();
+				var a1 = sa * alpha / 255,
+					a2 = 1 - a1;
+				dst[i] = a1 * dr + a2 * br;
+				dst[i + 1] = a1 * dg + a2 * bg;
+				dst[i + 2] = a1 * db + a2 * bb;
+				dst[i + 3] = sa * alpha + a2 * ba;
+			}
+			dstContext.putImageData(dstData, offset.x, offset.y);
+		}
+	};
+};
+
+var SvgElement = new function() {
+	var svg = 'http://www.w3.org/2000/svg',
+		xmlns = 'http://www.w3.org/2000/xmlns',
+		xlink = 'http://www.w3.org/1999/xlink',
+		attributeNamespace = {
+			href: xlink,
+			xlink: xmlns,
+			xmlns: xmlns + '/',
+			'xmlns:xlink': xmlns + '/'
+		};
+
+	function create(tag, attributes, formatter) {
+		return set(document.createElementNS(svg, tag), attributes, formatter);
+	}
+
+	function get(node, name) {
+		var namespace = attributeNamespace[name],
+			value = namespace
+				? node.getAttributeNS(namespace, name)
+				: node.getAttribute(name);
+		return value === 'null' ? null : value;
+	}
+
+	function set(node, attributes, formatter) {
+		for (var name in attributes) {
+			var value = attributes[name],
+				namespace = attributeNamespace[name];
+			if (typeof value === 'number' && formatter)
+				value = formatter.number(value);
+			if (namespace) {
+				node.setAttributeNS(namespace, name, value);
+			} else {
+				node.setAttribute(name, value);
+			}
+		}
+		return node;
+	}
+
+	return {
+		svg: svg,
+		xmlns: xmlns,
+		xlink: xlink,
+
+		create: create,
+		get: get,
+		set: set
+	};
+};
+
+var SvgStyles = Base.each({
+	fillColor: ['fill', 'color'],
+	fillRule: ['fill-rule', 'string'],
+	strokeColor: ['stroke', 'color'],
+	strokeWidth: ['stroke-width', 'number'],
+	strokeCap: ['stroke-linecap', 'string'],
+	strokeJoin: ['stroke-linejoin', 'string'],
+	strokeScaling: ['vector-effect', 'lookup', {
+		true: 'none',
+		false: 'non-scaling-stroke'
+	}, function(item, value) {
+		return !value
+				&& (item instanceof PathItem
+					|| item instanceof Shape
+					|| item instanceof TextItem);
+	}],
+	miterLimit: ['stroke-miterlimit', 'number'],
+	dashArray: ['stroke-dasharray', 'array'],
+	dashOffset: ['stroke-dashoffset', 'number'],
+	fontFamily: ['font-family', 'string'],
+	fontWeight: ['font-weight', 'string'],
+	fontSize: ['font-size', 'number'],
+	justification: ['text-anchor', 'lookup', {
+		left: 'start',
+		center: 'middle',
+		right: 'end'
+	}],
+	opacity: ['opacity', 'number'],
+	blendMode: ['mix-blend-mode', 'style']
+}, function(entry, key) {
+	var part = Base.capitalize(key),
+		lookup = entry[2];
+	this[key] = {
+		type: entry[1],
+		property: key,
+		attribute: entry[0],
+		toSVG: lookup,
+		fromSVG: lookup && Base.each(lookup, function(value, name) {
+			this[value] = name;
+		}, {}),
+		exportFilter: entry[3],
+		get: 'get' + part,
+		set: 'set' + part
+	};
+}, {});
+
+new function() {
+	var formatter;
+
+	function getTransform(matrix, coordinates, center) {
+		var attrs = new Base(),
+			trans = matrix.getTranslation();
+		if (coordinates) {
+			var point;
+			if (matrix.isInvertible()) {
+				matrix = matrix._shiftless();
+				point = matrix._inverseTransform(trans);
+				trans = null;
+			} else {
+				point = new Point();
+			}
+			attrs[center ? 'cx' : 'x'] = point.x;
+			attrs[center ? 'cy' : 'y'] = point.y;
+		}
+		if (!matrix.isIdentity()) {
+			var decomposed = matrix.decompose();
+			if (decomposed) {
+				var parts = [],
+					angle = decomposed.rotation,
+					scale = decomposed.scaling,
+					skew = decomposed.skewing;
+				if (trans && !trans.isZero())
+					parts.push('translate(' + formatter.point(trans) + ')');
+				if (angle)
+					parts.push('rotate(' + formatter.number(angle) + ')');
+				if (!Numerical.isZero(scale.x - 1)
+						|| !Numerical.isZero(scale.y - 1))
+					parts.push('scale(' + formatter.point(scale) +')');
+				if (skew.x)
+					parts.push('skewX(' + formatter.number(skew.x) + ')');
+				if (skew.y)
+					parts.push('skewY(' + formatter.number(skew.y) + ')');
+				attrs.transform = parts.join(' ');
+			} else {
+				attrs.transform = 'matrix(' + matrix.getValues().join(',') + ')';
+			}
+		}
+		return attrs;
+	}
+
+	function exportGroup(item, options) {
+		var attrs = getTransform(item._matrix),
+			children = item._children;
+		var node = SvgElement.create('g', attrs, formatter);
+		for (var i = 0, l = children.length; i < l; i++) {
+			var child = children[i];
+			var childNode = exportSVG(child, options);
+			if (childNode) {
+				if (child.isClipMask()) {
+					var clip = SvgElement.create('clipPath');
+					clip.appendChild(childNode);
+					setDefinition(child, clip, 'clip');
+					SvgElement.set(node, {
+						'clip-path': 'url(#' + clip.id + ')'
+					});
+				} else {
+					node.appendChild(childNode);
+				}
+			}
+		}
+		return node;
+	}
+
+	function exportRaster(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			size = item.getSize(),
+			image = item.getImage();
+		attrs.x -= size.width / 2;
+		attrs.y -= size.height / 2;
+		attrs.width = size.width;
+		attrs.height = size.height;
+		attrs.href = options.embedImages == false && image && image.src
+				|| item.toDataURL();
+		return SvgElement.create('image', attrs, formatter);
+	}
+
+	function exportPath(item, options) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
+			var shape = item.toShape(false);
+			if (shape)
+				return exportShape(shape, options);
+		}
+		var segments = item._segments,
+			length = segments.length,
+			type,
+			attrs = getTransform(item._matrix);
+		if (matchShapes && length >= 2 && !item.hasHandles()) {
+			if (length > 2) {
+				type = item._closed ? 'polygon' : 'polyline';
+				var parts = [];
+				for (var i = 0; i < length; i++) {
+					parts.push(formatter.point(segments[i]._point));
+				}
+				attrs.points = parts.join(' ');
+			} else {
+				type = 'line';
+				var start = segments[0]._point,
+					end = segments[1]._point;
+				attrs.set({
+					x1: start.x,
+					y1: start.y,
+					x2: end.x,
+					y2: end.y
+				});
+			}
+		} else {
+			type = 'path';
+			attrs.d = item.getPathData(null, options.precision);
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportShape(item) {
+		var type = item._type,
+			radius = item._radius,
+			attrs = getTransform(item._matrix, true, type !== 'rectangle');
+		if (type === 'rectangle') {
+			type = 'rect';
+			var size = item._size,
+				width = size.width,
+				height = size.height;
+			attrs.x -= width / 2;
+			attrs.y -= height / 2;
+			attrs.width = width;
+			attrs.height = height;
+			if (radius.isZero())
+				radius = null;
+		}
+		if (radius) {
+			if (type === 'circle') {
+				attrs.r = radius;
+			} else {
+				attrs.rx = radius.width;
+				attrs.ry = radius.height;
+			}
+		}
+		return SvgElement.create(type, attrs, formatter);
+	}
+
+	function exportCompoundPath(item, options) {
+		var attrs = getTransform(item._matrix);
+		var data = item.getPathData(null, options.precision);
+		if (data)
+			attrs.d = data;
+		return SvgElement.create('path', attrs, formatter);
+	}
+
+	function exportSymbolItem(item, options) {
+		var attrs = getTransform(item._matrix, true),
+			definition = item._definition,
+			node = getDefinition(definition, 'symbol'),
+			definitionItem = definition._item,
+			bounds = definitionItem.getStrokeBounds();
+		if (!node) {
+			node = SvgElement.create('symbol', {
+				viewBox: formatter.rectangle(bounds)
+			});
+			node.appendChild(exportSVG(definitionItem, options));
+			setDefinition(definition, node, 'symbol');
+		}
+		attrs.href = '#' + node.id;
+		attrs.x += bounds.x;
+		attrs.y += bounds.y;
+		attrs.width = bounds.width;
+		attrs.height = bounds.height;
+		attrs.overflow = 'visible';
+		return SvgElement.create('use', attrs, formatter);
+	}
+
+	function exportGradient(color) {
+		var gradientNode = getDefinition(color, 'color');
+		if (!gradientNode) {
+			var gradient = color.getGradient(),
+				radial = gradient._radial,
+				origin = color.getOrigin(),
+				destination = color.getDestination(),
+				attrs;
+			if (radial) {
+				attrs = {
+					cx: origin.x,
+					cy: origin.y,
+					r: origin.getDistance(destination)
+				};
+				var highlight = color.getHighlight();
+				if (highlight) {
+					attrs.fx = highlight.x;
+					attrs.fy = highlight.y;
+				}
+			} else {
+				attrs = {
+					x1: origin.x,
+					y1: origin.y,
+					x2: destination.x,
+					y2: destination.y
+				};
+			}
+			attrs.gradientUnits = 'userSpaceOnUse';
+			gradientNode = SvgElement.create((radial ? 'radial' : 'linear')
+					+ 'Gradient', attrs, formatter);
+			var stops = gradient._stops;
+			for (var i = 0, l = stops.length; i < l; i++) {
+				var stop = stops[i],
+					stopColor = stop._color,
+					alpha = stopColor.getAlpha(),
+					offset = stop._offset;
+				attrs = {
+					offset: offset == null ? i / (l - 1) : offset
+				};
+				if (stopColor)
+					attrs['stop-color'] = stopColor.toCSS(true);
+				if (alpha < 1)
+					attrs['stop-opacity'] = alpha;
+				gradientNode.appendChild(
+						SvgElement.create('stop', attrs, formatter));
+			}
+			setDefinition(color, gradientNode, 'color');
+		}
+		return 'url(#' + gradientNode.id + ')';
+	}
+
+	function exportText(item) {
+		var node = SvgElement.create('text', getTransform(item._matrix, true),
+				formatter);
+		node.textContent = item._content;
+		return node;
+	}
+
+	var exporters = {
+		Group: exportGroup,
+		Layer: exportGroup,
+		Raster: exportRaster,
+		Path: exportPath,
+		Shape: exportShape,
+		CompoundPath: exportCompoundPath,
+		SymbolItem: exportSymbolItem,
+		PointText: exportText
+	};
+
+	function applyStyle(item, node, isRoot) {
+		var attrs = {},
+			parent = !isRoot && item.getParent(),
+			style = [];
+
+		if (item._name != null)
+			attrs.id = item._name;
+
+		Base.each(SvgStyles, function(entry) {
+			var get = entry.get,
+				type = entry.type,
+				value = item[get]();
+			if (entry.exportFilter
+					? entry.exportFilter(item, value)
+					: !parent || !Base.equals(parent[get](), value)) {
+				if (type === 'color' && value != null) {
+					var alpha = value.getAlpha();
+					if (alpha < 1)
+						attrs[entry.attribute + '-opacity'] = alpha;
+				}
+				if (type === 'style') {
+					style.push(entry.attribute + ': ' + value);
+				} else {
+					attrs[entry.attribute] = value == null ? 'none'
+							: type === 'color' ? value.gradient
+								? exportGradient(value, item)
+								: value.toCSS(true)
+							: type === 'array' ? value.join(',')
+							: type === 'lookup' ? entry.toSVG[value]
+							: value;
+				}
+			}
+		});
+
+		if (style.length)
+			attrs.style = style.join(';');
+
+		if (attrs.opacity === 1)
+			delete attrs.opacity;
+
+		if (!item._visible)
+			attrs.visibility = 'hidden';
+
+		return SvgElement.set(node, attrs, formatter);
+	}
+
+	var definitions;
+	function getDefinition(item, type) {
+		if (!definitions)
+			definitions = { ids: {}, svgs: {} };
+		return item && definitions.svgs[type + '-'
+				+ (item._id || item.__id || (item.__id = UID.get('svg')))];
+	}
+
+	function setDefinition(item, node, type) {
+		if (!definitions)
+			getDefinition();
+		var typeId = definitions.ids[type] = (definitions.ids[type] || 0) + 1;
+		node.id = type + '-' + typeId;
+		definitions.svgs[type + '-' + (item._id || item.__id)] = node;
+	}
+
+	function exportDefinitions(node, options) {
+		var svg = node,
+			defs = null;
+		if (definitions) {
+			svg = node.nodeName.toLowerCase() === 'svg' && node;
+			for (var i in definitions.svgs) {
+				if (!defs) {
+					if (!svg) {
+						svg = SvgElement.create('svg');
+						svg.appendChild(node);
+					}
+					defs = svg.insertBefore(SvgElement.create('defs'),
+							svg.firstChild);
+				}
+				defs.appendChild(definitions.svgs[i]);
+			}
+			definitions = null;
+		}
+		return options.asString
+				? new self.XMLSerializer().serializeToString(svg)
+				: svg;
+	}
+
+	function exportSVG(item, options, isRoot) {
+		var exporter = exporters[item._class],
+			node = exporter && exporter(item, options);
+		if (node) {
+			var onExport = options.onExport;
+			if (onExport)
+				node = onExport(item, node, options) || node;
+			var data = JSON.stringify(item._data);
+			if (data && data !== '{}' && data !== 'null')
+				node.setAttribute('data-paper-data', data);
+		}
+		return node && applyStyle(item, node, isRoot);
+	}
+
+	function setOptions(options) {
+		if (!options)
+			options = {};
+		formatter = new Formatter(options.precision);
+		return options;
+	}
+
+	Item.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			return exportDefinitions(exportSVG(this, options, true), options);
+		}
+	});
+
+	Project.inject({
+		exportSVG: function(options) {
+			options = setOptions(options);
+			var children = this._children,
+				view = this.getView(),
+				bounds = Base.pick(options.bounds, 'view'),
+				mx = options.matrix || bounds === 'view' && view._matrix,
+				matrix = mx && Matrix.read([mx]),
+				rect = bounds === 'view'
+					? new Rectangle([0, 0], view.getViewSize())
+					: bounds === 'content'
+						? Item._getBounds(children, matrix, { stroke: true })
+							.rect
+						: Rectangle.read([bounds], 0, { readNull: true }),
+				attrs = {
+					version: '1.1',
+					xmlns: SvgElement.svg,
+					'xmlns:xlink': SvgElement.xlink,
+				};
+			if (rect) {
+				attrs.width = rect.width;
+				attrs.height = rect.height;
+				if (rect.x || rect.x === 0 || rect.y || rect.y === 0)
+					attrs.viewBox = formatter.rectangle(rect);
+			}
+			var node = SvgElement.create('svg', attrs, formatter),
+				parent = node;
+			if (matrix && !matrix.isIdentity()) {
+				parent = node.appendChild(SvgElement.create('g',
+						getTransform(matrix), formatter));
+			}
+			for (var i = 0, l = children.length; i < l; i++) {
+				parent.appendChild(exportSVG(children[i], options, true));
+			}
+			return exportDefinitions(node, options);
+		}
+	});
+};
+
+new function() {
+
+	var definitions = {},
+		rootSize;
+
+	function getValue(node, name, isString, allowNull, allowPercent,
+			defaultValue) {
+		var value = SvgElement.get(node, name) || defaultValue,
+			res = value == null
+				? allowNull
+					? null
+					: isString ? '' : 0
+				: isString
+					? value
+					: parseFloat(value);
+		return /%\s*$/.test(value)
+			? (res / 100) * (allowPercent ? 1
+				: rootSize[/x|^width/.test(name) ? 'width' : 'height'])
+			: res;
+	}
+
+	function getPoint(node, x, y, allowNull, allowPercent, defaultX, defaultY) {
+		x = getValue(node, x || 'x', false, allowNull, allowPercent, defaultX);
+		y = getValue(node, y || 'y', false, allowNull, allowPercent, defaultY);
+		return allowNull && (x == null || y == null) ? null
+				: new Point(x, y);
+	}
+
+	function getSize(node, w, h, allowNull, allowPercent) {
+		w = getValue(node, w || 'width', false, allowNull, allowPercent);
+		h = getValue(node, h || 'height', false, allowNull, allowPercent);
+		return allowNull && (w == null || h == null) ? null
+				: new Size(w, h);
+	}
+
+	function convertValue(value, type, lookup) {
+		return value === 'none' ? null
+				: type === 'number' ? parseFloat(value)
+				: type === 'array' ?
+					value ? value.split(/[\s,]+/g).map(parseFloat) : []
+				: type === 'color' ? getDefinition(value) || value
+				: type === 'lookup' ? lookup[value]
+				: value;
+	}
+
+	function importGroup(node, type, options, isRoot) {
+		var nodes = node.childNodes,
+			isClip = type === 'clippath',
+			isDefs = type === 'defs',
+			item = new Group(),
+			project = item._project,
+			currentStyle = project._currentStyle,
+			children = [];
+		if (!isClip && !isDefs) {
+			item = applyAttributes(item, node, isRoot);
+			project._currentStyle = item._style.clone();
+		}
+		if (isRoot) {
+			var defs = node.querySelectorAll('defs');
+			for (var i = 0, l = defs.length; i < l; i++) {
+				importNode(defs[i], options, false);
+			}
+		}
+		for (var i = 0, l = nodes.length; i < l; i++) {
+			var childNode = nodes[i],
+				child;
+			if (childNode.nodeType === 1
+					&& !/^defs$/i.test(childNode.nodeName)
+					&& (child = importNode(childNode, options, false))
+					&& !(child instanceof SymbolDefinition))
+				children.push(child);
+		}
+		item.addChildren(children);
+		if (isClip)
+			item = applyAttributes(item.reduce(), node, isRoot);
+		project._currentStyle = currentStyle;
+		if (isClip || isDefs) {
+			item.remove();
+			item = null;
+		}
+		return item;
+	}
+
+	function importPoly(node, type) {
+		var coords = node.getAttribute('points').match(
+					/[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g),
+			points = [];
+		for (var i = 0, l = coords.length; i < l; i += 2)
+			points.push(new Point(
+					parseFloat(coords[i]),
+					parseFloat(coords[i + 1])));
+		var path = new Path(points);
+		if (type === 'polygon')
+			path.closePath();
+		return path;
+	}
+
+	function importPath(node) {
+		return PathItem.create(node.getAttribute('d'));
+	}
+
+	function importGradient(node, type) {
+		var id = (getValue(node, 'href', true) || '').substring(1),
+			radial = type === 'radialgradient',
+			gradient;
+		if (id) {
+			gradient = definitions[id].getGradient();
+			if (gradient._radial ^ radial) {
+				gradient = gradient.clone();
+				gradient._radial = radial;
+			}
+		} else {
+			var nodes = node.childNodes,
+				stops = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					stops.push(applyAttributes(new GradientStop(), child));
+			}
+			gradient = new Gradient(stops, radial);
+		}
+		var origin, destination, highlight,
+			scaleToBounds = getValue(node, 'gradientUnits', true) !==
+				'userSpaceOnUse';
+		if (radial) {
+			origin = getPoint(node, 'cx', 'cy', false, scaleToBounds,
+				'50%', '50%');
+			destination = origin.add(
+				getValue(node, 'r', false, false, scaleToBounds, '50%'), 0);
+			highlight = getPoint(node, 'fx', 'fy', true, scaleToBounds);
+		} else {
+			origin = getPoint(node, 'x1', 'y1', false, scaleToBounds,
+				'0%', '0%');
+			destination = getPoint(node, 'x2', 'y2', false, scaleToBounds,
+				'100%', '0%');
+		}
+		var color = applyAttributes(
+				new Color(gradient, origin, destination, highlight), node);
+		color._scaleToBounds = scaleToBounds;
+		return null;
+	}
+
+	var importers = {
+		'#document': function (node, type, options, isRoot) {
+			var nodes = node.childNodes;
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				var child = nodes[i];
+				if (child.nodeType === 1)
+					return importNode(child, options, isRoot);
+			}
+		},
+		g: importGroup,
+		svg: importGroup,
+		clippath: importGroup,
+		polygon: importPoly,
+		polyline: importPoly,
+		path: importPath,
+		lineargradient: importGradient,
+		radialgradient: importGradient,
+
+		image: function (node) {
+			var raster = new Raster(getValue(node, 'href', true));
+			raster.on('load', function() {
+				var size = getSize(node);
+				this.setSize(size);
+				var center = getPoint(node).add(size.divide(2));
+				this._matrix.append(new Matrix().translate(center));
+			});
+			return raster;
+		},
+
+		symbol: function(node, type, options, isRoot) {
+			return new SymbolDefinition(
+					importGroup(node, type, options, isRoot), true);
+		},
+
+		defs: importGroup,
+
+		use: function(node) {
+			var id = (getValue(node, 'href', true) || '').substring(1),
+				definition = definitions[id],
+				point = getPoint(node);
+			return definition
+					? definition instanceof SymbolDefinition
+						? definition.place(point)
+						: definition.clone().translate(point)
+					: null;
+		},
+
+		circle: function(node) {
+			return new Shape.Circle(
+					getPoint(node, 'cx', 'cy'),
+					getValue(node, 'r'));
+		},
+
+		ellipse: function(node) {
+			return new Shape.Ellipse({
+				center: getPoint(node, 'cx', 'cy'),
+				radius: getSize(node, 'rx', 'ry')
+			});
+		},
+
+		rect: function(node) {
+			return new Shape.Rectangle(new Rectangle(
+						getPoint(node),
+						getSize(node)
+					), getSize(node, 'rx', 'ry'));
+			},
+
+		line: function(node) {
+			return new Path.Line(
+					getPoint(node, 'x1', 'y1'),
+					getPoint(node, 'x2', 'y2'));
+		},
+
+		text: function(node) {
+			var text = new PointText(getPoint(node).add(
+					getPoint(node, 'dx', 'dy')));
+			text.setContent(node.textContent.trim() || '');
+			return text;
+		},
+
+		switch: importGroup
+	};
+
+	function applyTransform(item, value, name, node) {
+		if (item.transform) {
+			var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
+				matrix = new Matrix();
+			for (var i = 0, l = transforms.length; i < l; i++) {
+				var transform = transforms[i];
+				if (!transform)
+					break;
+				var parts = transform.split(/\(\s*/),
+					command = parts[0],
+					v = parts[1].split(/[\s,]+/g);
+				for (var j = 0, m = v.length; j < m; j++)
+					v[j] = parseFloat(v[j]);
+				switch (command) {
+				case 'matrix':
+					matrix.append(
+							new Matrix(v[0], v[1], v[2], v[3], v[4], v[5]));
+					break;
+				case 'rotate':
+					matrix.rotate(v[0], v[1] || 0, v[2] || 0);
+					break;
+				case 'translate':
+					matrix.translate(v[0], v[1] || 0);
+					break;
+				case 'scale':
+					matrix.scale(v);
+					break;
+				case 'skewX':
+					matrix.skew(v[0], 0);
+					break;
+				case 'skewY':
+					matrix.skew(0, v[0]);
+					break;
+				}
+			}
+			item.transform(matrix);
+		}
+	}
+
+	function applyOpacity(item, value, name) {
+		var key = name === 'fill-opacity' ? 'getFillColor' : 'getStrokeColor',
+			color = item[key] && item[key]();
+		if (color)
+			color.setAlpha(parseFloat(value));
+	}
+
+	var attributes = Base.set(Base.each(SvgStyles, function(entry) {
+		this[entry.attribute] = function(item, value) {
+			if (item[entry.set]) {
+				item[entry.set](convertValue(value, entry.type, entry.fromSVG));
+				if (entry.type === 'color') {
+					var color = item[entry.get]();
+					if (color) {
+						if (color._scaleToBounds) {
+							var bounds = item.getBounds();
+							color.transform(new Matrix()
+								.translate(bounds.getPoint())
+								.scale(bounds.getSize()));
+						}
+					}
+				}
+			}
+		};
+	}, {}), {
+		id: function(item, value) {
+			definitions[value] = item;
+			if (item.setName)
+				item.setName(value);
+		},
+
+		'clip-path': function(item, value) {
+			var clip = getDefinition(value);
+			if (clip) {
+				clip = clip.clone();
+				clip.setClipMask(true);
+				if (item instanceof Group) {
+					item.insertChild(0, clip);
+				} else {
+					return new Group(clip, item);
+				}
+			}
+		},
+
+		gradientTransform: applyTransform,
+		transform: applyTransform,
+
+		'fill-opacity': applyOpacity,
+		'stroke-opacity': applyOpacity,
+
+		visibility: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value === 'visible');
+		},
+
+		display: function(item, value) {
+			if (item.setVisible)
+				item.setVisible(value !== null);
+		},
+
+		'stop-color': function(item, value) {
+			if (item.setColor)
+				item.setColor(value);
+		},
+
+		'stop-opacity': function(item, value) {
+			if (item._color)
+				item._color.setAlpha(parseFloat(value));
+		},
+
+		offset: function(item, value) {
+			if (item.setOffset) {
+				var percent = value.match(/(.*)%$/);
+				item.setOffset(percent ? percent[1] / 100 : parseFloat(value));
+			}
+		},
+
+		viewBox: function(item, value, name, node, styles) {
+			var rect = new Rectangle(convertValue(value, 'array')),
+				size = getSize(node, null, null, true),
+				group,
+				matrix;
+			if (item instanceof Group) {
+				var scale = size ? size.divide(rect.getSize()) : 1,
+				matrix = new Matrix().scale(scale)
+						.translate(rect.getPoint().negate());
+				group = item;
+			} else if (item instanceof SymbolDefinition) {
+				if (size)
+					rect.setSize(size);
+				group = item._item;
+			}
+			if (group)  {
+				if (getAttribute(node, 'overflow', styles) !== 'visible') {
+					var clip = new Shape.Rectangle(rect);
+					clip.setClipMask(true);
+					group.addChild(clip);
+				}
+				if (matrix)
+					group.transform(matrix);
+			}
+		}
+	});
+
+	function getAttribute(node, name, styles) {
+		var attr = node.attributes[name],
+			value = attr && attr.value;
+		if (!value && node.style) {
+			var style = Base.camelize(name);
+			value = node.style[style];
+			if (!value && styles.node[style] !== styles.parent[style])
+				value = styles.node[style];
+		}
+		return !value ? undefined
+				: value === 'none' ? null
+				: value;
+	}
+
+	function applyAttributes(item, node, isRoot) {
+		var parent = node.parentNode,
+			styles = {
+				node: DomElement.getStyles(node) || {},
+				parent: !isRoot && !/^defs$/i.test(parent.tagName)
+						&& DomElement.getStyles(parent) || {}
+			};
+		Base.each(attributes, function(apply, name) {
+			var value = getAttribute(node, name, styles);
+			item = value !== undefined
+					&& apply(item, value, name, node, styles) || item;
+		});
+		return item;
+	}
+
+	function getDefinition(value) {
+		var match = value && value.match(/\((?:["'#]*)([^"')]+)/),
+			name = match && match[1],
+			res = name && definitions[window
+					? name.replace(window.location.href.split('#')[0] + '#', '')
+					: name];
+		if (res && res._scaleToBounds) {
+			res = res.clone();
+			res._scaleToBounds = true;
+		}
+		return res;
+	}
+
+	function importNode(node, options, isRoot) {
+		var type = node.nodeName.toLowerCase(),
+			isElement = type !== '#document',
+			body = document.body,
+			container,
+			parent,
+			next;
+		if (isRoot && isElement) {
+			rootSize = paper.getView().getSize();
+			rootSize = getSize(node, null, null, true) || rootSize;
+			container = SvgElement.create('svg', {
+				style: 'stroke-width: 1px; stroke-miterlimit: 10'
+			});
+			parent = node.parentNode;
+			next = node.nextSibling;
+			container.appendChild(node);
+			body.appendChild(container);
+		}
+		var settings = paper.settings,
+			applyMatrix = settings.applyMatrix,
+			insertItems = settings.insertItems;
+		settings.applyMatrix = false;
+		settings.insertItems = false;
+		var importer = importers[type],
+			item = importer && importer(node, type, options, isRoot) || null;
+		settings.insertItems = insertItems;
+		settings.applyMatrix = applyMatrix;
+		if (item) {
+			if (isElement && !(item instanceof Group))
+				item = applyAttributes(item, node, isRoot);
+			var onImport = options.onImport,
+				data = isElement && node.getAttribute('data-paper-data');
+			if (onImport)
+				item = onImport(node, item, options) || item;
+			if (options.expandShapes && item instanceof Shape) {
+				item.remove();
+				item = item.toPath();
+			}
+			if (data)
+				item._data = JSON.parse(data);
+		}
+		if (container) {
+			body.removeChild(container);
+			if (parent) {
+				if (next) {
+					parent.insertBefore(node, next);
+				} else {
+					parent.appendChild(node);
+				}
+			}
+		}
+		if (isRoot) {
+			definitions = {};
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
+				item.matrix.apply(true, true);
+		}
+		return item;
+	}
+
+	function importSVG(source, options, owner) {
+		if (!source)
+			return null;
+		options = typeof options === 'function' ? { onLoad: options }
+				: options || {};
+		var scope = paper,
+			item = null;
+
+		function onLoad(svg) {
+			try {
+				var node = typeof svg === 'object'
+					? svg
+					: new self.DOMParser().parseFromString(
+						svg,
+						'image/svg+xml'
+					);
+				if (!node.nodeName) {
+					node = null;
+					throw new Error('Unsupported SVG source: ' + source);
+				}
+				paper = scope;
+				item = importNode(node, options, true);
+				if (!options || options.insert !== false) {
+					owner._insertItem(undefined, item);
+				}
+				var onLoad = options.onLoad;
+				if (onLoad)
+					onLoad(item, svg);
+			} catch (e) {
+				onError(e);
+			}
+		}
+
+		function onError(message, status) {
+			var onError = options.onError;
+			if (onError) {
+				onError(message, status);
+			} else {
+				throw new Error(message);
+			}
+		}
+
+		if (typeof source === 'string' && !/^[\s\S]*</.test(source)) {
+			var node = document.getElementById(source);
+			if (node) {
+				onLoad(node);
+			} else {
+				Http.request({
+					url: source,
+					async: true,
+					onLoad: onLoad,
+					onError: onError
+				});
+			}
+		} else if (typeof File !== 'undefined' && source instanceof File) {
+			var reader = new FileReader();
+			reader.onload = function() {
+				onLoad(reader.result);
+			};
+			reader.onerror = function() {
+				onError(reader.error);
+			};
+			return reader.readAsText(source);
+		} else {
+			onLoad(source);
+		}
+
+		return item;
+	}
+
+	Item.inject({
+		importSVG: function(node, options) {
+			return importSVG(node, options, this);
+		}
+	});
+
+	Project.inject({
+		importSVG: function(node, options) {
+			this.activate();
+			return importSVG(node, options, this);
+		}
+	});
+};
+
+Base.exports.PaperScript = function() {
+	var global = this,
+		acorn = global.acorn;
+	if (!acorn && typeof require !== 'undefined') {
+		try { acorn = require('acorn'); } catch(e) {}
+	}
+	if (!acorn) {
+		var exports, module;
+		acorn = exports = module = {};
+
+(function(root, mod) {
+  if (typeof exports == "object" && typeof module == "object") return mod(exports);
+  if (typeof define == "function" && define.amd) return define(["exports"], mod);
+  mod(root.acorn || (root.acorn = {}));
+})(this, function(exports) {
+  "use strict";
+
+  exports.version = "0.5.0";
+
+  var options, input, inputLen, sourceFile;
+
+  exports.parse = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+	return parseTopLevel(options.program);
+  };
+
+  var defaultOptions = exports.defaultOptions = {
+	ecmaVersion: 5,
+	strictSemicolons: false,
+	allowTrailingCommas: true,
+	forbidReserved: false,
+	allowReturnOutsideFunction: false,
+	locations: false,
+	onComment: null,
+	ranges: false,
+	program: null,
+	sourceFile: null,
+	directSourceFile: null
+  };
+
+  function setOptions(opts) {
+	options = opts || {};
+	for (var opt in defaultOptions) if (!Object.prototype.hasOwnProperty.call(options, opt))
+	  options[opt] = defaultOptions[opt];
+	sourceFile = options.sourceFile || null;
+  }
+
+  var getLineInfo = exports.getLineInfo = function(input, offset) {
+	for (var line = 1, cur = 0;;) {
+	  lineBreak.lastIndex = cur;
+	  var match = lineBreak.exec(input);
+	  if (match && match.index < offset) {
+		++line;
+		cur = match.index + match[0].length;
+	  } else break;
+	}
+	return {line: line, column: offset - cur};
+  };
+
+  exports.tokenize = function(inpt, opts) {
+	input = String(inpt); inputLen = input.length;
+	setOptions(opts);
+	initTokenState();
+
+	var t = {};
+	function getToken(forceRegexp) {
+	  lastEnd = tokEnd;
+	  readToken(forceRegexp);
+	  t.start = tokStart; t.end = tokEnd;
+	  t.startLoc = tokStartLoc; t.endLoc = tokEndLoc;
+	  t.type = tokType; t.value = tokVal;
+	  return t;
+	}
+	getToken.jumpTo = function(pos, reAllowed) {
+	  tokPos = pos;
+	  if (options.locations) {
+		tokCurLine = 1;
+		tokLineStart = lineBreak.lastIndex = 0;
+		var match;
+		while ((match = lineBreak.exec(input)) && match.index < pos) {
+		  ++tokCurLine;
+		  tokLineStart = match.index + match[0].length;
+		}
+	  }
+	  tokRegexpAllowed = reAllowed;
+	  skipSpace();
+	};
+	return getToken;
+  };
+
+  var tokPos;
+
+  var tokStart, tokEnd;
+
+  var tokStartLoc, tokEndLoc;
+
+  var tokType, tokVal;
+
+  var tokRegexpAllowed;
+
+  var tokCurLine, tokLineStart;
+
+  var lastStart, lastEnd, lastEndLoc;
+
+  var inFunction, labels, strict;
+
+  function raise(pos, message) {
+	var loc = getLineInfo(input, pos);
+	message += " (" + loc.line + ":" + loc.column + ")";
+	var err = new SyntaxError(message);
+	err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
+	throw err;
+  }
+
+  var empty = [];
+
+  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
+  var _name = {type: "name"}, _eof = {type: "eof"};
+
+  var _break = {keyword: "break"}, _case = {keyword: "case", beforeExpr: true}, _catch = {keyword: "catch"};
+  var _continue = {keyword: "continue"}, _debugger = {keyword: "debugger"}, _default = {keyword: "default"};
+  var _do = {keyword: "do", isLoop: true}, _else = {keyword: "else", beforeExpr: true};
+  var _finally = {keyword: "finally"}, _for = {keyword: "for", isLoop: true}, _function = {keyword: "function"};
+  var _if = {keyword: "if"}, _return = {keyword: "return", beforeExpr: true}, _switch = {keyword: "switch"};
+  var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
+  var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
+  var _this = {keyword: "this"};
+
+  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
+
+  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+
+  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+					  "continue": _continue, "debugger": _debugger, "default": _default,
+					  "do": _do, "else": _else, "finally": _finally, "for": _for,
+					  "function": _function, "if": _if, "return": _return, "switch": _switch,
+					  "throw": _throw, "try": _try, "var": _var, "while": _while, "with": _with,
+					  "null": _null, "true": _true, "false": _false, "new": _new, "in": _in,
+					  "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
+					  "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
+					  "void": {keyword: "void", prefix: true, beforeExpr: true},
+					  "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
+
+  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+  var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
+  var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _question = {type: "?", beforeExpr: true};
+
+  var _slash = {binop: 10, beforeExpr: true}, _eq = {isAssign: true, beforeExpr: true};
+  var _assign = {isAssign: true, beforeExpr: true};
+  var _incDec = {postfix: true, prefix: true, isUpdate: true}, _prefix = {prefix: true, beforeExpr: true};
+  var _logicalOR = {binop: 1, beforeExpr: true};
+  var _logicalAND = {binop: 2, beforeExpr: true};
+  var _bitwiseOR = {binop: 3, beforeExpr: true};
+  var _bitwiseXOR = {binop: 4, beforeExpr: true};
+  var _bitwiseAND = {binop: 5, beforeExpr: true};
+  var _equality = {binop: 6, beforeExpr: true};
+  var _relational = {binop: 7, beforeExpr: true};
+  var _bitShift = {binop: 8, beforeExpr: true};
+  var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
+  var _multiplyModulo = {binop: 10, beforeExpr: true};
+
+  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
+					  parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
+					  dot: _dot, question: _question, slash: _slash, eq: _eq, name: _name, eof: _eof,
+					  num: _num, regexp: _regexp, string: _string};
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
+
+  function makePredicate(words) {
+	words = words.split(" ");
+	var f = "", cats = [];
+	out: for (var i = 0; i < words.length; ++i) {
+	  for (var j = 0; j < cats.length; ++j)
+		if (cats[j][0].length == words[i].length) {
+		  cats[j].push(words[i]);
+		  continue out;
+		}
+	  cats.push([words[i]]);
+	}
+	function compareTo(arr) {
+	  if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+	  f += "switch(str){";
+	  for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+	  f += "return true}return false;";
+	}
+
+	if (cats.length > 3) {
+	  cats.sort(function(a, b) {return b.length - a.length;});
+	  f += "switch(str.length){";
+	  for (var i = 0; i < cats.length; ++i) {
+		var cat = cats[i];
+		f += "case " + cat[0].length + ":";
+		compareTo(cat);
+	  }
+	  f += "}";
+
+	} else {
+	  compareTo(words);
+	}
+	return new Function("str", f);
+  }
+
+  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
+
+  var isReservedWord5 = makePredicate("class enum extends super const export import");
+
+  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+
+  var isStrictBadIdWord = makePredicate("eval arguments");
+
+  var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+
+  var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+  var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+  var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+  var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+
+  var newline = /[\n\r\u2028\u2029]/;
+
+  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+
+  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+	if (code < 65) return code === 36;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  };
+
+  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+	if (code < 48) return code === 36;
+	if (code < 58) return true;
+	if (code < 65) return false;
+	if (code < 91) return true;
+	if (code < 97) return code === 95;
+	if (code < 123)return true;
+	return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  };
+
+  function line_loc_t() {
+	this.line = tokCurLine;
+	this.column = tokPos - tokLineStart;
+  }
+
+  function initTokenState() {
+	tokCurLine = 1;
+	tokPos = tokLineStart = 0;
+	tokRegexpAllowed = true;
+	skipSpace();
+  }
+
+  function finishToken(type, val) {
+	tokEnd = tokPos;
+	if (options.locations) tokEndLoc = new line_loc_t;
+	tokType = type;
+	skipSpace();
+	tokVal = val;
+	tokRegexpAllowed = type.beforeExpr;
+  }
+
+  function skipBlockComment() {
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var start = tokPos, end = input.indexOf("*/", tokPos += 2);
+	if (end === -1) raise(tokPos - 2, "Unterminated comment");
+	tokPos = end + 2;
+	if (options.locations) {
+	  lineBreak.lastIndex = start;
+	  var match;
+	  while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+		++tokCurLine;
+		tokLineStart = match.index + match[0].length;
+	  }
+	}
+	if (options.onComment)
+	  options.onComment(true, input.slice(start + 2, end), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipLineComment() {
+	var start = tokPos;
+	var startLoc = options.onComment && options.locations && new line_loc_t;
+	var ch = input.charCodeAt(tokPos+=2);
+	while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+	  ++tokPos;
+	  ch = input.charCodeAt(tokPos);
+	}
+	if (options.onComment)
+	  options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
+						startLoc, options.locations && new line_loc_t);
+  }
+
+  function skipSpace() {
+	while (tokPos < inputLen) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === 32) {
+		++tokPos;
+	  } else if (ch === 13) {
+		++tokPos;
+		var next = input.charCodeAt(tokPos);
+		if (next === 10) {
+		  ++tokPos;
+		}
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch === 10 || ch === 8232 || ch === 8233) {
+		++tokPos;
+		if (options.locations) {
+		  ++tokCurLine;
+		  tokLineStart = tokPos;
+		}
+	  } else if (ch > 8 && ch < 14) {
+		++tokPos;
+	  } else if (ch === 47) {
+		var next = input.charCodeAt(tokPos + 1);
+		if (next === 42) {
+		  skipBlockComment();
+		} else if (next === 47) {
+		  skipLineComment();
+		} else break;
+	  } else if (ch === 160) {
+		++tokPos;
+	  } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+		++tokPos;
+	  } else {
+		break;
+	  }
+	}
+  }
+
+  function readToken_dot() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next >= 48 && next <= 57) return readNumber(true);
+	++tokPos;
+	return finishToken(_dot);
+  }
+
+  function readToken_slash() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (tokRegexpAllowed) {++tokPos; return readRegexp();}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_slash, 1);
+  }
+
+  function readToken_mult_modulo() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_multiplyModulo, 1);
+  }
+
+  function readToken_pipe_amp(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  }
+
+  function readToken_caret() {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_bitwiseXOR, 1);
+  }
+
+  function readToken_plus_min(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === code) {
+	  if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
+		  newline.test(input.slice(lastEnd, tokPos))) {
+		tokPos += 3;
+		skipLineComment();
+		skipSpace();
+		return readToken();
+	  }
+	  return finishOp(_incDec, 2);
+	}
+	if (next === 61) return finishOp(_assign, 2);
+	return finishOp(_plusMin, 1);
+  }
+
+  function readToken_lt_gt(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	var size = 1;
+	if (next === code) {
+	  size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+	  if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
+	  return finishOp(_bitShift, size);
+	}
+	if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
+		input.charCodeAt(tokPos + 3) == 45) {
+	  tokPos += 4;
+	  skipLineComment();
+	  skipSpace();
+	  return readToken();
+	}
+	if (next === 61)
+	  size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+	return finishOp(_relational, size);
+  }
+
+  function readToken_eq_excl(code) {
+	var next = input.charCodeAt(tokPos + 1);
+	if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+	return finishOp(code === 61 ? _eq : _prefix, 1);
+  }
+
+  function getTokenFromCode(code) {
+	switch(code) {
+	case 46:
+	  return readToken_dot();
+
+	case 40: ++tokPos; return finishToken(_parenL);
+	case 41: ++tokPos; return finishToken(_parenR);
+	case 59: ++tokPos; return finishToken(_semi);
+	case 44: ++tokPos; return finishToken(_comma);
+	case 91: ++tokPos; return finishToken(_bracketL);
+	case 93: ++tokPos; return finishToken(_bracketR);
+	case 123: ++tokPos; return finishToken(_braceL);
+	case 125: ++tokPos; return finishToken(_braceR);
+	case 58: ++tokPos; return finishToken(_colon);
+	case 63: ++tokPos; return finishToken(_question);
+
+	case 48:
+	  var next = input.charCodeAt(tokPos + 1);
+	  if (next === 120 || next === 88) return readHexNumber();
+	case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
+	  return readNumber(false);
+
+	case 34: case 39:
+	  return readString(code);
+
+	case 47:
+	  return readToken_slash(code);
+
+	case 37: case 42:
+	  return readToken_mult_modulo();
+
+	case 124: case 38:
+	  return readToken_pipe_amp(code);
+
+	case 94:
+	  return readToken_caret();
+
+	case 43: case 45:
+	  return readToken_plus_min(code);
+
+	case 60: case 62:
+	  return readToken_lt_gt(code);
+
+	case 61: case 33:
+	  return readToken_eq_excl(code);
+
+	case 126:
+	  return finishOp(_prefix, 1);
+	}
+
+	return false;
+  }
+
+  function readToken(forceRegexp) {
+	if (!forceRegexp) tokStart = tokPos;
+	else tokPos = tokStart + 1;
+	if (options.locations) tokStartLoc = new line_loc_t;
+	if (forceRegexp) return readRegexp();
+	if (tokPos >= inputLen) return finishToken(_eof);
+
+	var code = input.charCodeAt(tokPos);
+	if (isIdentifierStart(code) || code === 92 ) return readWord();
+
+	var tok = getTokenFromCode(code);
+
+	if (tok === false) {
+	  var ch = String.fromCharCode(code);
+	  if (ch === "\\" || nonASCIIidentifierStart.test(ch)) return readWord();
+	  raise(tokPos, "Unexpected character '" + ch + "'");
+	}
+	return tok;
+  }
+
+  function finishOp(type, size) {
+	var str = input.slice(tokPos, tokPos + size);
+	tokPos += size;
+	finishToken(type, str);
+  }
+
+  function readRegexp() {
+	var content = "", escaped, inClass, start = tokPos;
+	for (;;) {
+	  if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
+	  var ch = input.charAt(tokPos);
+	  if (newline.test(ch)) raise(start, "Unterminated regular expression");
+	  if (!escaped) {
+		if (ch === "[") inClass = true;
+		else if (ch === "]" && inClass) inClass = false;
+		else if (ch === "/" && !inClass) break;
+		escaped = ch === "\\";
+	  } else escaped = false;
+	  ++tokPos;
+	}
+	var content = input.slice(start, tokPos);
+	++tokPos;
+	var mods = readWord1();
+	if (mods && !/^[gmsiy]*$/.test(mods)) raise(start, "Invalid regexp flag");
+	try {
+	  var value = new RegExp(content, mods);
+	} catch (e) {
+	  if (e instanceof SyntaxError) raise(start, e.message);
+	  raise(e);
+	}
+	return finishToken(_regexp, value);
+  }
+
+  function readInt(radix, len) {
+	var start = tokPos, total = 0;
+	for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	  var code = input.charCodeAt(tokPos), val;
+	  if (code >= 97) val = code - 97 + 10;
+	  else if (code >= 65) val = code - 65 + 10;
+	  else if (code >= 48 && code <= 57) val = code - 48;
+	  else val = Infinity;
+	  if (val >= radix) break;
+	  ++tokPos;
+	  total = total * radix + val;
+	}
+	if (tokPos === start || len != null && tokPos - start !== len) return null;
+
+	return total;
+  }
+
+  function readHexNumber() {
+	tokPos += 2;
+	var val = readInt(16);
+	if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+	return finishToken(_num, val);
+  }
+
+  function readNumber(startsWithDot) {
+	var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
+	if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
+	if (input.charCodeAt(tokPos) === 46) {
+	  ++tokPos;
+	  readInt(10);
+	  isFloat = true;
+	}
+	var next = input.charCodeAt(tokPos);
+	if (next === 69 || next === 101) {
+	  next = input.charCodeAt(++tokPos);
+	  if (next === 43 || next === 45) ++tokPos;
+	  if (readInt(10) === null) raise(start, "Invalid number");
+	  isFloat = true;
+	}
+	if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
+
+	var str = input.slice(start, tokPos), val;
+	if (isFloat) val = parseFloat(str);
+	else if (!octal || str.length === 1) val = parseInt(str, 10);
+	else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
+	else val = parseInt(str, 8);
+	return finishToken(_num, val);
+  }
+
+  function readString(quote) {
+	tokPos++;
+	var out = "";
+	for (;;) {
+	  if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+	  var ch = input.charCodeAt(tokPos);
+	  if (ch === quote) {
+		++tokPos;
+		return finishToken(_string, out);
+	  }
+	  if (ch === 92) {
+		ch = input.charCodeAt(++tokPos);
+		var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+		if (octal) octal = octal[0];
+		while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+		if (octal === "0") octal = null;
+		++tokPos;
+		if (octal) {
+		  if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+		  out += String.fromCharCode(parseInt(octal, 8));
+		  tokPos += octal.length - 1;
+		} else {
+		  switch (ch) {
+		  case 110: out += "\n"; break;
+		  case 114: out += "\r"; break;
+		  case 120: out += String.fromCharCode(readHexChar(2)); break;
+		  case 117: out += String.fromCharCode(readHexChar(4)); break;
+		  case 85: out += String.fromCharCode(readHexChar(8)); break;
+		  case 116: out += "\t"; break;
+		  case 98: out += "\b"; break;
+		  case 118: out += "\u000b"; break;
+		  case 102: out += "\f"; break;
+		  case 48: out += "\0"; break;
+		  case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos;
+		  case 10:
+			if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
+			break;
+		  default: out += String.fromCharCode(ch); break;
+		  }
+		}
+	  } else {
+		if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) raise(tokStart, "Unterminated string constant");
+		out += String.fromCharCode(ch);
+		++tokPos;
+	  }
+	}
+  }
+
+  function readHexChar(len) {
+	var n = readInt(16, len);
+	if (n === null) raise(tokStart, "Bad character escape sequence");
+	return n;
+  }
+
+  var containsEsc;
+
+  function readWord1() {
+	containsEsc = false;
+	var word, first = true, start = tokPos;
+	for (;;) {
+	  var ch = input.charCodeAt(tokPos);
+	  if (isIdentifierChar(ch)) {
+		if (containsEsc) word += input.charAt(tokPos);
+		++tokPos;
+	  } else if (ch === 92) {
+		if (!containsEsc) word = input.slice(start, tokPos);
+		containsEsc = true;
+		if (input.charCodeAt(++tokPos) != 117)
+		  raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+		++tokPos;
+		var esc = readHexChar(4);
+		var escStr = String.fromCharCode(esc);
+		if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+		if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc)))
+		  raise(tokPos - 4, "Invalid Unicode escape");
+		word += escStr;
+	  } else {
+		break;
+	  }
+	  first = false;
+	}
+	return containsEsc ? word : input.slice(start, tokPos);
+  }
+
+  function readWord() {
+	var word = readWord1();
+	var type = _name;
+	if (!containsEsc && isKeyword(word))
+	  type = keywordTypes[word];
+	return finishToken(type, word);
+  }
+
+  function next() {
+	lastStart = tokStart;
+	lastEnd = tokEnd;
+	lastEndLoc = tokEndLoc;
+	readToken();
+  }
+
+  function setStrict(strct) {
+	strict = strct;
+	tokPos = tokStart;
+	if (options.locations) {
+	  while (tokPos < tokLineStart) {
+		tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+		--tokCurLine;
+	  }
+	}
+	skipSpace();
+	readToken();
+  }
+
+  function node_t() {
+	this.type = null;
+	this.start = tokStart;
+	this.end = null;
+  }
+
+  function node_loc_t() {
+	this.start = tokStartLoc;
+	this.end = null;
+	if (sourceFile !== null) this.source = sourceFile;
+  }
+
+  function startNode() {
+	var node = new node_t();
+	if (options.locations)
+	  node.loc = new node_loc_t();
+	if (options.directSourceFile)
+	  node.sourceFile = options.directSourceFile;
+	if (options.ranges)
+	  node.range = [tokStart, 0];
+	return node;
+  }
+
+  function startNodeFrom(other) {
+	var node = new node_t();
+	node.start = other.start;
+	if (options.locations) {
+	  node.loc = new node_loc_t();
+	  node.loc.start = other.loc.start;
+	}
+	if (options.ranges)
+	  node.range = [other.range[0], 0];
+
+	return node;
+  }
+
+  function finishNode(node, type) {
+	node.type = type;
+	node.end = lastEnd;
+	if (options.locations)
+	  node.loc.end = lastEndLoc;
+	if (options.ranges)
+	  node.range[1] = lastEnd;
+	return node;
+  }
+
+  function isUseStrict(stmt) {
+	return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+	  stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+  }
+
+  function eat(type) {
+	if (tokType === type) {
+	  next();
+	  return true;
+	}
+  }
+
+  function canInsertSemicolon() {
+	return !options.strictSemicolons &&
+	  (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+  }
+
+  function semicolon() {
+	if (!eat(_semi) && !canInsertSemicolon()) unexpected();
+  }
+
+  function expect(type) {
+	if (tokType === type) next();
+	else unexpected();
+  }
+
+  function unexpected() {
+	raise(tokStart, "Unexpected token");
+  }
+
+  function checkLVal(expr) {
+	if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
+	  raise(expr.start, "Assigning to rvalue");
+	if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
+	  raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+  }
+
+  function parseTopLevel(program) {
+	lastStart = lastEnd = tokPos;
+	if (options.locations) lastEndLoc = new line_loc_t;
+	inFunction = strict = null;
+	labels = [];
+	readToken();
+
+	var node = program || startNode(), first = true;
+	if (!program) node.body = [];
+	while (tokType !== _eof) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && isUseStrict(stmt)) setStrict(true);
+	  first = false;
+	}
+	return finishNode(node, "Program");
+  }
+
+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
+
+  function parseStatement() {
+	if (tokType === _slash || tokType === _assign && tokVal == "/=")
+	  readToken(true);
+
+	var starttype = tokType, node = startNode();
+
+	switch (starttype) {
+	case _break: case _continue:
+	  next();
+	  var isBreak = starttype === _break;
+	  if (eat(_semi) || canInsertSemicolon()) node.label = null;
+	  else if (tokType !== _name) unexpected();
+	  else {
+		node.label = parseIdent();
+		semicolon();
+	  }
+
+	  for (var i = 0; i < labels.length; ++i) {
+		var lab = labels[i];
+		if (node.label == null || lab.name === node.label.name) {
+		  if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
+		  if (node.label && isBreak) break;
+		}
+	  }
+	  if (i === labels.length) raise(node.start, "Unsyntactic " + starttype.keyword);
+	  return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+
+	case _debugger:
+	  next();
+	  semicolon();
+	  return finishNode(node, "DebuggerStatement");
+
+	case _do:
+	  next();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  expect(_while);
+	  node.test = parseParenExpression();
+	  semicolon();
+	  return finishNode(node, "DoWhileStatement");
+
+	case _for:
+	  next();
+	  labels.push(loopLabel);
+	  expect(_parenL);
+	  if (tokType === _semi) return parseFor(node, null);
+	  if (tokType === _var) {
+		var init = startNode();
+		next();
+		parseVar(init, true);
+		finishNode(init, "VariableDeclaration");
+		if (init.declarations.length === 1 && eat(_in))
+		  return parseForIn(node, init);
+		return parseFor(node, init);
+	  }
+	  var init = parseExpression(false, true);
+	  if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+	  return parseFor(node, init);
+
+	case _function:
+	  next();
+	  return parseFunction(node, true);
+
+	case _if:
+	  next();
+	  node.test = parseParenExpression();
+	  node.consequent = parseStatement();
+	  node.alternate = eat(_else) ? parseStatement() : null;
+	  return finishNode(node, "IfStatement");
+
+	case _return:
+	  if (!inFunction && !options.allowReturnOutsideFunction)
+		raise(tokStart, "'return' outside of function");
+	  next();
+
+	  if (eat(_semi) || canInsertSemicolon()) node.argument = null;
+	  else { node.argument = parseExpression(); semicolon(); }
+	  return finishNode(node, "ReturnStatement");
+
+	case _switch:
+	  next();
+	  node.discriminant = parseParenExpression();
+	  node.cases = [];
+	  expect(_braceL);
+	  labels.push(switchLabel);
+
+	  for (var cur, sawDefault; tokType != _braceR;) {
+		if (tokType === _case || tokType === _default) {
+		  var isCase = tokType === _case;
+		  if (cur) finishNode(cur, "SwitchCase");
+		  node.cases.push(cur = startNode());
+		  cur.consequent = [];
+		  next();
+		  if (isCase) cur.test = parseExpression();
+		  else {
+			if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+			cur.test = null;
+		  }
+		  expect(_colon);
+		} else {
+		  if (!cur) unexpected();
+		  cur.consequent.push(parseStatement());
+		}
+	  }
+	  if (cur) finishNode(cur, "SwitchCase");
+	  next();
+	  labels.pop();
+	  return finishNode(node, "SwitchStatement");
+
+	case _throw:
+	  next();
+	  if (newline.test(input.slice(lastEnd, tokStart)))
+		raise(lastEnd, "Illegal newline after throw");
+	  node.argument = parseExpression();
+	  semicolon();
+	  return finishNode(node, "ThrowStatement");
+
+	case _try:
+	  next();
+	  node.block = parseBlock();
+	  node.handler = null;
+	  if (tokType === _catch) {
+		var clause = startNode();
+		next();
+		expect(_parenL);
+		clause.param = parseIdent();
+		if (strict && isStrictBadIdWord(clause.param.name))
+		  raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+		expect(_parenR);
+		clause.guard = null;
+		clause.body = parseBlock();
+		node.handler = finishNode(clause, "CatchClause");
+	  }
+	  node.guardedHandlers = empty;
+	  node.finalizer = eat(_finally) ? parseBlock() : null;
+	  if (!node.handler && !node.finalizer)
+		raise(node.start, "Missing catch or finally clause");
+	  return finishNode(node, "TryStatement");
+
+	case _var:
+	  next();
+	  parseVar(node);
+	  semicolon();
+	  return finishNode(node, "VariableDeclaration");
+
+	case _while:
+	  next();
+	  node.test = parseParenExpression();
+	  labels.push(loopLabel);
+	  node.body = parseStatement();
+	  labels.pop();
+	  return finishNode(node, "WhileStatement");
+
+	case _with:
+	  if (strict) raise(tokStart, "'with' in strict mode");
+	  next();
+	  node.object = parseParenExpression();
+	  node.body = parseStatement();
+	  return finishNode(node, "WithStatement");
+
+	case _braceL:
+	  return parseBlock();
+
+	case _semi:
+	  next();
+	  return finishNode(node, "EmptyStatement");
+
+	default:
+	  var maybeName = tokVal, expr = parseExpression();
+	  if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+		for (var i = 0; i < labels.length; ++i)
+		  if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
+		var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+		labels.push({name: maybeName, kind: kind});
+		node.body = parseStatement();
+		labels.pop();
+		node.label = expr;
+		return finishNode(node, "LabeledStatement");
+	  } else {
+		node.expression = expr;
+		semicolon();
+		return finishNode(node, "ExpressionStatement");
+	  }
+	}
+  }
+
+  function parseParenExpression() {
+	expect(_parenL);
+	var val = parseExpression();
+	expect(_parenR);
+	return val;
+  }
+
+  function parseBlock(allowStrict) {
+	var node = startNode(), first = true, strict = false, oldStrict;
+	node.body = [];
+	expect(_braceL);
+	while (!eat(_braceR)) {
+	  var stmt = parseStatement();
+	  node.body.push(stmt);
+	  if (first && allowStrict && isUseStrict(stmt)) {
+		oldStrict = strict;
+		setStrict(strict = true);
+	  }
+	  first = false;
+	}
+	if (strict && !oldStrict) setStrict(false);
+	return finishNode(node, "BlockStatement");
+  }
+
+  function parseFor(node, init) {
+	node.init = init;
+	expect(_semi);
+	node.test = tokType === _semi ? null : parseExpression();
+	expect(_semi);
+	node.update = tokType === _parenR ? null : parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForStatement");
+  }
+
+  function parseForIn(node, init) {
+	node.left = init;
+	node.right = parseExpression();
+	expect(_parenR);
+	node.body = parseStatement();
+	labels.pop();
+	return finishNode(node, "ForInStatement");
+  }
+
+  function parseVar(node, noIn) {
+	node.declarations = [];
+	node.kind = "var";
+	for (;;) {
+	  var decl = startNode();
+	  decl.id = parseIdent();
+	  if (strict && isStrictBadIdWord(decl.id.name))
+		raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+	  decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+	  node.declarations.push(finishNode(decl, "VariableDeclarator"));
+	  if (!eat(_comma)) break;
+	}
+	return node;
+  }
+
+  function parseExpression(noComma, noIn) {
+	var expr = parseMaybeAssign(noIn);
+	if (!noComma && tokType === _comma) {
+	  var node = startNodeFrom(expr);
+	  node.expressions = [expr];
+	  while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+	  return finishNode(node, "SequenceExpression");
+	}
+	return expr;
+  }
+
+  function parseMaybeAssign(noIn) {
+	var left = parseMaybeConditional(noIn);
+	if (tokType.isAssign) {
+	  var node = startNodeFrom(left);
+	  node.operator = tokVal;
+	  node.left = left;
+	  next();
+	  node.right = parseMaybeAssign(noIn);
+	  checkLVal(left);
+	  return finishNode(node, "AssignmentExpression");
+	}
+	return left;
+  }
+
+  function parseMaybeConditional(noIn) {
+	var expr = parseExprOps(noIn);
+	if (eat(_question)) {
+	  var node = startNodeFrom(expr);
+	  node.test = expr;
+	  node.consequent = parseExpression(true);
+	  expect(_colon);
+	  node.alternate = parseExpression(true, noIn);
+	  return finishNode(node, "ConditionalExpression");
+	}
+	return expr;
+  }
+
+  function parseExprOps(noIn) {
+	return parseExprOp(parseMaybeUnary(), -1, noIn);
+  }
+
+  function parseExprOp(left, minPrec, noIn) {
+	var prec = tokType.binop;
+	if (prec != null && (!noIn || tokType !== _in)) {
+	  if (prec > minPrec) {
+		var node = startNodeFrom(left);
+		node.left = left;
+		node.operator = tokVal;
+		var op = tokType;
+		next();
+		node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+		var exprNode = finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+		return parseExprOp(exprNode, minPrec, noIn);
+	  }
+	}
+	return left;
+  }
+
+  function parseMaybeUnary() {
+	if (tokType.prefix) {
+	  var node = startNode(), update = tokType.isUpdate;
+	  node.operator = tokVal;
+	  node.prefix = true;
+	  tokRegexpAllowed = true;
+	  next();
+	  node.argument = parseMaybeUnary();
+	  if (update) checkLVal(node.argument);
+	  else if (strict && node.operator === "delete" &&
+			   node.argument.type === "Identifier")
+		raise(node.start, "Deleting local variable in strict mode");
+	  return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+	}
+	var expr = parseExprSubscripts();
+	while (tokType.postfix && !canInsertSemicolon()) {
+	  var node = startNodeFrom(expr);
+	  node.operator = tokVal;
+	  node.prefix = false;
+	  node.argument = expr;
+	  checkLVal(expr);
+	  next();
+	  expr = finishNode(node, "UpdateExpression");
+	}
+	return expr;
+  }
+
+  function parseExprSubscripts() {
+	return parseSubscripts(parseExprAtom());
+  }
+
+  function parseSubscripts(base, noCalls) {
+	if (eat(_dot)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseIdent(true);
+	  node.computed = false;
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (eat(_bracketL)) {
+	  var node = startNodeFrom(base);
+	  node.object = base;
+	  node.property = parseExpression();
+	  node.computed = true;
+	  expect(_bracketR);
+	  return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+	} else if (!noCalls && eat(_parenL)) {
+	  var node = startNodeFrom(base);
+	  node.callee = base;
+	  node.arguments = parseExprList(_parenR, false);
+	  return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+	} else return base;
+  }
+
+  function parseExprAtom() {
+	switch (tokType) {
+	case _this:
+	  var node = startNode();
+	  next();
+	  return finishNode(node, "ThisExpression");
+	case _name:
+	  return parseIdent();
+	case _num: case _string: case _regexp:
+	  var node = startNode();
+	  node.value = tokVal;
+	  node.raw = input.slice(tokStart, tokEnd);
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _null: case _true: case _false:
+	  var node = startNode();
+	  node.value = tokType.atomValue;
+	  node.raw = tokType.keyword;
+	  next();
+	  return finishNode(node, "Literal");
+
+	case _parenL:
+	  var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+	  next();
+	  var val = parseExpression();
+	  val.start = tokStart1;
+	  val.end = tokEnd;
+	  if (options.locations) {
+		val.loc.start = tokStartLoc1;
+		val.loc.end = tokEndLoc;
+	  }
+	  if (options.ranges)
+		val.range = [tokStart1, tokEnd];
+	  expect(_parenR);
+	  return val;
+
+	case _bracketL:
+	  var node = startNode();
+	  next();
+	  node.elements = parseExprList(_bracketR, true, true);
+	  return finishNode(node, "ArrayExpression");
+
+	case _braceL:
+	  return parseObj();
+
+	case _function:
+	  var node = startNode();
+	  next();
+	  return parseFunction(node, false);
+
+	case _new:
+	  return parseNew();
+
+	default:
+	  unexpected();
+	}
+  }
+
+  function parseNew() {
+	var node = startNode();
+	next();
+	node.callee = parseSubscripts(parseExprAtom(), true);
+	if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+	else node.arguments = empty;
+	return finishNode(node, "NewExpression");
+  }
+
+  function parseObj() {
+	var node = startNode(), first = true, sawGetSet = false;
+	node.properties = [];
+	next();
+	while (!eat(_braceR)) {
+	  if (!first) {
+		expect(_comma);
+		if (options.allowTrailingCommas && eat(_braceR)) break;
+	  } else first = false;
+
+	  var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+	  if (eat(_colon)) {
+		prop.value = parseExpression(true);
+		kind = prop.kind = "init";
+	  } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+				 (prop.key.name === "get" || prop.key.name === "set")) {
+		isGetSet = sawGetSet = true;
+		kind = prop.kind = prop.key.name;
+		prop.key = parsePropertyName();
+		if (tokType !== _parenL) unexpected();
+		prop.value = parseFunction(startNode(), false);
+	  } else unexpected();
+
+	  if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+		for (var i = 0; i < node.properties.length; ++i) {
+		  var other = node.properties[i];
+		  if (other.key.name === prop.key.name) {
+			var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
+			  kind === "init" && (other.kind === "get" || other.kind === "set");
+			if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
+			if (conflict) raise(prop.key.start, "Redefinition of property");
+		  }
+		}
+	  }
+	  node.properties.push(prop);
+	}
+	return finishNode(node, "ObjectExpression");
+  }
+
+  function parsePropertyName() {
+	if (tokType === _num || tokType === _string) return parseExprAtom();
+	return parseIdent(true);
+  }
+
+  function parseFunction(node, isStatement) {
+	if (tokType === _name) node.id = parseIdent();
+	else if (isStatement) unexpected();
+	else node.id = null;
+	node.params = [];
+	var first = true;
+	expect(_parenL);
+	while (!eat(_parenR)) {
+	  if (!first) expect(_comma); else first = false;
+	  node.params.push(parseIdent());
+	}
+
+	var oldInFunc = inFunction, oldLabels = labels;
+	inFunction = true; labels = [];
+	node.body = parseBlock(true);
+	inFunction = oldInFunc; labels = oldLabels;
+
+	if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+	  for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+		var id = i < 0 ? node.id : node.params[i];
+		if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
+		  raise(id.start, "Defining '" + id.name + "' in strict mode");
+		if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
+		  raise(id.start, "Argument name clash in strict mode");
+	  }
+	}
+
+	return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
+
+  function parseExprList(close, allowTrailingComma, allowEmpty) {
+	var elts = [], first = true;
+	while (!eat(close)) {
+	  if (!first) {
+		expect(_comma);
+		if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+	  } else first = false;
+
+	  if (allowEmpty && tokType === _comma) elts.push(null);
+	  else elts.push(parseExpression(true));
+	}
+	return elts;
+  }
+
+  function parseIdent(liberal) {
+	var node = startNode();
+	if (liberal && options.forbidReserved == "everywhere") liberal = false;
+	if (tokType === _name) {
+	  if (!liberal &&
+		  (options.forbidReserved &&
+		   (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
+		   strict && isStrictReservedWord(tokVal)) &&
+		  input.slice(tokStart, tokEnd).indexOf("\\") == -1)
+		raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+	  node.name = tokVal;
+	} else if (liberal && tokType.keyword) {
+	  node.name = tokType.keyword;
+	} else {
+	  unexpected();
+	}
+	tokRegexpAllowed = false;
+	next();
+	return finishNode(node, "Identifier");
+  }
+
+});
+
+		if (!acorn.version)
+			acorn = null;
+	}
+
+	function parse(code, options) {
+		return (global.acorn || acorn).parse(code, options);
+	}
+
+	var binaryOperators = {
+		'+': '__add',
+		'-': '__subtract',
+		'*': '__multiply',
+		'/': '__divide',
+		'%': '__modulo',
+		'==': '__equals',
+		'!=': '__equals'
+	};
+
+	var unaryOperators = {
+		'-': '__negate',
+		'+': '__self'
+	};
+
+	var fields = Base.each(
+		['add', 'subtract', 'multiply', 'divide', 'modulo', 'equals', 'negate'],
+		function(name) {
+			this['__' + name] = '#' + name;
+		},
+		{
+			__self: function() {
+				return this;
+			}
+		}
+	);
+	Point.inject(fields);
+	Size.inject(fields);
+	Color.inject(fields);
+
+	function __$__(left, operator, right) {
+		var handler = binaryOperators[operator];
+		if (left && left[handler]) {
+			var res = left[handler](right);
+			return operator === '!=' ? !res : res;
+		}
+		switch (operator) {
+		case '+': return left + right;
+		case '-': return left - right;
+		case '*': return left * right;
+		case '/': return left / right;
+		case '%': return left % right;
+		case '==': return left == right;
+		case '!=': return left != right;
+		}
+	}
+
+	function $__(operator, value) {
+		var handler = unaryOperators[operator];
+		if (value && value[handler])
+			return value[handler]();
+		switch (operator) {
+		case '+': return +value;
+		case '-': return -value;
+		}
+	}
+
+	function compile(code, options) {
+		if (!code)
+			return '';
+		options = options || {};
+
+		var insertions = [];
+
+		function getOffset(offset) {
+			for (var i = 0, l = insertions.length; i < l; i++) {
+				var insertion = insertions[i];
+				if (insertion[0] >= offset)
+					break;
+				offset += insertion[1];
+			}
+			return offset;
+		}
+
+		function getCode(node) {
+			return code.substring(getOffset(node.range[0]),
+					getOffset(node.range[1]));
+		}
+
+		function getBetween(left, right) {
+			return code.substring(getOffset(left.range[1]),
+					getOffset(right.range[0]));
+		}
+
+		function replaceCode(node, str) {
+			var start = getOffset(node.range[0]),
+				end = getOffset(node.range[1]),
+				insert = 0;
+			for (var i = insertions.length - 1; i >= 0; i--) {
+				if (start > insertions[i][0]) {
+					insert = i + 1;
+					break;
+				}
+			}
+			insertions.splice(insert, 0, [start, str.length - end + start]);
+			code = code.substring(0, start) + str + code.substring(end);
+		}
+
+		function handleOverloading(node, parent) {
+			switch (node.type) {
+			case 'UnaryExpression':
+				if (node.operator in unaryOperators
+						&& node.argument.type !== 'Literal') {
+					var arg = getCode(node.argument);
+					replaceCode(node, '$__("' + node.operator + '", '
+							+ arg + ')');
+				}
+				break;
+			case 'BinaryExpression':
+				if (node.operator in binaryOperators
+						&& node.left.type !== 'Literal') {
+					var left = getCode(node.left),
+						right = getCode(node.right),
+						between = getBetween(node.left, node.right),
+						operator = node.operator;
+					replaceCode(node, '__$__(' + left + ','
+							+ between.replace(new RegExp('\\' + operator),
+								'"' + operator + '"')
+							+ ', ' + right + ')');
+				}
+				break;
+			case 'UpdateExpression':
+			case 'AssignmentExpression':
+				var parentType = parent && parent.type;
+				if (!(
+						parentType === 'ForStatement'
+						|| parentType === 'BinaryExpression'
+							&& /^[=!<>]/.test(parent.operator)
+						|| parentType === 'MemberExpression' && parent.computed
+				)) {
+					if (node.type === 'UpdateExpression') {
+						var arg = getCode(node.argument),
+							exp = '__$__(' + arg + ', "' + node.operator[0]
+									+ '", 1)',
+							str = arg + ' = ' + exp;
+						if (node.prefix) {
+							str = '(' + str + ')';
+						} else if (
+							parentType === 'AssignmentExpression' ||
+							parentType === 'VariableDeclarator' ||
+							parentType === 'BinaryExpression'
+						) {
+							if (getCode(parent.left || parent.id) === arg)
+								str = exp;
+							str = arg + '; ' + str;
+						}
+						replaceCode(node, str);
+					} else {
+						if (/^.=$/.test(node.operator)
+								&& node.left.type !== 'Literal') {
+							var left = getCode(node.left),
+								right = getCode(node.right),
+								exp = left + ' = __$__(' + left + ', "'
+									+ node.operator[0] + '", ' + right + ')';
+							replaceCode(node, /^\(.*\)$/.test(getCode(node))
+									? '(' + exp + ')' : exp);
+						}
+					}
+				}
+				break;
+			}
+		}
+
+		function handleExports(node) {
+			switch (node.type) {
+			case 'ExportDefaultDeclaration':
+				replaceCode({
+					range: [node.start, node.declaration.start]
+				}, 'module.exports = ');
+				break;
+			case 'ExportNamedDeclaration':
+				var declaration = node.declaration;
+				var specifiers = node.specifiers;
+				if (declaration) {
+					var declarations = declaration.declarations;
+					if (declarations) {
+						declarations.forEach(function(dec) {
+							replaceCode(dec, 'module.exports.' + getCode(dec));
+						});
+						replaceCode({
+							range: [
+								node.start,
+								declaration.start + declaration.kind.length
+							]
+						}, '');
+					}
+				} else if (specifiers) {
+					var exports = specifiers.map(function(specifier) {
+						var name = getCode(specifier);
+						return 'module.exports.' + name + ' = ' + name + '; ';
+					}).join('');
+					if (exports) {
+						replaceCode(node, exports);
+					}
+				}
+				break;
+			}
+		}
+
+		function walkAST(node, parent, paperFeatures) {
+			if (node) {
+				for (var key in node) {
+					if (key !== 'range' && key !== 'loc') {
+						var value = node[key];
+						if (Array.isArray(value)) {
+							for (var i = 0, l = value.length; i < l; i++) {
+								walkAST(value[i], node, paperFeatures);
+							}
+						} else if (value && typeof value === 'object') {
+							walkAST(value, node, paperFeatures);
+						}
+					}
+				}
+				if (paperFeatures.operatorOverloading !== false) {
+					handleOverloading(node, parent);
+				}
+				if (paperFeatures.moduleExports !== false) {
+					handleExports(node);
+				}
+			}
+		}
+
+		function encodeVLQ(value) {
+			var res = '',
+				base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+			value = (Math.abs(value) << 1) + (value < 0 ? 1 : 0);
+			while (value || !res) {
+				var next = value & (32 - 1);
+				value >>= 5;
+				if (value)
+					next |= 32;
+				res += base64[next];
+			}
+			return res;
+		}
+
+		var url = options.url || '',
+			sourceMaps = options.sourceMaps,
+			paperFeatures = options.paperFeatures || {},
+			source = options.source || code,
+			offset = options.offset || 0,
+			agent = paper.agent,
+			version = agent.versionNumber,
+			offsetCode = false,
+			lineBreaks = /\r\n|\n|\r/mg,
+			map;
+		if (sourceMaps && (agent.chrome && version >= 30
+				|| agent.webkit && version >= 537.76
+				|| agent.firefox && version >= 23
+				|| agent.node)) {
+			if (agent.node) {
+				offset -= 2;
+			} else if (window && url && !window.location.href.indexOf(url)) {
+				var html = document.getElementsByTagName('html')[0].innerHTML;
+				offset = html.substr(0, html.indexOf(code) + 1).match(
+						lineBreaks).length + 1;
+			}
+			offsetCode = offset > 0 && !(
+					agent.chrome && version >= 36 ||
+					agent.safari && version >= 600 ||
+					agent.firefox && version >= 40 ||
+					agent.node);
+			var mappings = ['AA' + encodeVLQ(offsetCode ? 0 : offset) + 'A'];
+			mappings.length = (code.match(lineBreaks) || []).length + 1
+					+ (offsetCode ? offset : 0);
+			map = {
+				version: 3,
+				file: url,
+				names:[],
+				mappings: mappings.join(';AACA'),
+				sourceRoot: '',
+				sources: [url],
+				sourcesContent: [source]
+			};
+		}
+		if (
+			paperFeatures.operatorOverloading !== false ||
+			paperFeatures.moduleExports !== false
+		) {
+			walkAST(parse(code, {
+				ranges: true,
+				preserveParens: true,
+				sourceType: 'module'
+			}), null, paperFeatures);
+		}
+		if (map) {
+			if (offsetCode) {
+				code = new Array(offset + 1).join('\n') + code;
+			}
+			if (/^(inline|both)$/.test(sourceMaps)) {
+				code += "\n//# sourceMappingURL=data:application/json;base64,"
+						+ self.btoa(unescape(encodeURIComponent(
+							JSON.stringify(map))));
+			}
+			code += "\n//# sourceURL=" + (url || 'paperscript');
+		}
+		return {
+			url: url,
+			source: source,
+			code: code,
+			map: map
+		};
+	}
+
+	function execute(code, scope, options) {
+		paper = scope;
+		var view = scope.getView(),
+			tool = /\btool\.\w+|\s+on(?:Key|Mouse)(?:Up|Down|Move|Drag)\b/
+					.test(code) && !/\bnew\s+Tool\b/.test(code)
+						? new Tool() : null,
+			toolHandlers = tool ? tool._events : [],
+			handlers = ['onFrame', 'onResize'].concat(toolHandlers),
+			params = [],
+			args = [],
+			func,
+			compiled = typeof code === 'object' ? code : compile(code, options);
+		code = compiled.code;
+		function expose(scope, hidden) {
+			for (var key in scope) {
+				if ((hidden || !/^_/.test(key)) && new RegExp('([\\b\\s\\W]|^)'
+						+ key.replace(/\$/g, '\\$') + '\\b').test(code)) {
+					params.push(key);
+					args.push(scope[key]);
+				}
+			}
+		}
+		expose({ __$__: __$__, $__: $__, paper: scope, tool: tool },
+				true);
+		expose(scope);
+		code = 'var module = { exports: {} }; ' + code;
+		var exports = Base.each(handlers, function(key) {
+			if (new RegExp('\\s+' + key + '\\b').test(code)) {
+				params.push(key);
+				this.push('module.exports.' + key + ' = ' + key + ';');
+			}
+		}, []).join('\n');
+		if (exports) {
+			code += '\n' + exports;
+		}
+		code += '\nreturn module.exports;';
+		var agent = paper.agent;
+		if (document && (agent.chrome
+				|| agent.firefox && agent.versionNumber < 40)) {
+			var script = document.createElement('script'),
+				head = document.head || document.getElementsByTagName('head')[0];
+			if (agent.firefox)
+				code = '\n' + code;
+			script.appendChild(document.createTextNode(
+				'document.__paperscript__ = function(' + params + ') {' +
+					code +
+				'\n}'
+			));
+			head.appendChild(script);
+			func = document.__paperscript__;
+			delete document.__paperscript__;
+			head.removeChild(script);
+		} else {
+			func = Function(params, code);
+		}
+		var exports = func && func.apply(scope, args);
+		var obj = exports || {};
+		Base.each(toolHandlers, function(key) {
+			var value = obj[key];
+			if (value)
+				tool[key] = value;
+		});
+		if (view) {
+			if (obj.onResize)
+				view.setOnResize(obj.onResize);
+			view.emit('resize', {
+				size: view.size,
+				delta: new Point()
+			});
+			if (obj.onFrame)
+				view.setOnFrame(obj.onFrame);
+			view.requestUpdate();
+		}
+		return exports;
+	}
+
+	function loadScript(script) {
+		if (/^text\/(?:x-|)paperscript$/.test(script.type)
+				&& PaperScope.getAttribute(script, 'ignore') !== 'true') {
+			var canvasId = PaperScope.getAttribute(script, 'canvas'),
+				canvas = document.getElementById(canvasId),
+				src = script.src || script.getAttribute('data-src'),
+				async = PaperScope.hasAttribute(script, 'async'),
+				scopeAttribute = 'data-paper-scope';
+			if (!canvas)
+				throw new Error('Unable to find canvas with id "'
+						+ canvasId + '"');
+			var scope = PaperScope.get(canvas.getAttribute(scopeAttribute))
+						|| new PaperScope().setup(canvas);
+			canvas.setAttribute(scopeAttribute, scope._id);
+			if (src) {
+				Http.request({
+					url: src,
+					async: async,
+					mimeType: 'text/plain',
+					onLoad: function(code) {
+						execute(code, scope, src);
+					}
+				});
+			} else {
+				execute(script.innerHTML, scope, script.baseURI);
+			}
+			script.setAttribute('data-paper-ignore', 'true');
+			return scope;
+		}
+	}
+
+	function loadAll() {
+		Base.each(document && document.getElementsByTagName('script'),
+				loadScript);
+	}
+
+	function load(script) {
+		return script ? loadScript(script) : loadAll();
+	}
+
+	if (window) {
+		if (document.readyState === 'complete') {
+			setTimeout(loadAll);
+		} else {
+			DomEvent.add(window, { load: loadAll });
+		}
+	}
+
+	return {
+		compile: compile,
+		execute: execute,
+		load: load,
+		parse: parse,
+		calculateBinary: __$__,
+		calculateUnary: $__
+	};
+
+}.call(this);
+
+var paper = new (PaperScope.inject(Base.exports, {
+	Base: Base,
+	Numerical: Numerical,
+	Key: Key,
+	DomEvent: DomEvent,
+	DomElement: DomElement,
+	document: document,
+	window: window,
+	Symbol: SymbolDefinition,
+	PlacedSymbol: SymbolItem
+}))();
+
+if (paper.agent.node) {
+	require('./node/extend.js')(paper);
+}
+
+if (typeof define === 'function' && define.amd) {
+	define('paper', paper);
+} else if (typeof module === 'object' && module) {
+	module.exports = paper;
+}
+
+return paper;
+}.call(this, typeof self === 'object' ? self : null);
diff --git a/dist/paper.d.ts b/dist/paper.d.ts
index 758ca847..f11acb53 100644
--- a/dist/paper.d.ts
+++ b/dist/paper.d.ts
@@ -1,15 +1,15 @@
 /*!
- * Paper.js v0.12.6 - The Swiss Army Knife of Vector Graphics Scripting.
+ * Paper.js v0.12.7 - The Swiss Army Knife of Vector Graphics Scripting.
  * http://paperjs.org/
  *
- * Copyright (c) 2011 - 2019, Juerg Lehni & Jonathan Puckey
- * http://scratchdisk.com/ & https://puckey.studio/
+ * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey
+ * http://juerglehni.com/ & https://puckey.studio/
  *
  * Distributed under the MIT license. See LICENSE file for details.
  *
  * All rights reserved.
  *
- * Date: Sat May 23 20:53:04 2020 +0200
+ * Date: Sat May 23 23:05:09 2020 +0200
  *
  * This is an auto-generated type definition.
  */
diff --git a/package.json b/package.json
index 7298f5ce..dd207c45 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "paper",
-  "version": "0.12.6",
+  "version": "0.12.7",
   "description": "The Swiss Army Knife of Vector Graphics Scripting",
   "license": "MIT",
   "homepage": "http://paperjs.org",
@@ -9,10 +9,7 @@
     "url": "https://github.com/paperjs/paper.js"
   },
   "bugs": "https://github.com/paperjs/paper.js/issues",
-  "contributors": [
-    "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
-    "Jonathan Puckey <jonathan@puckey.studio> (http://studiomoniker.com)"
-  ],
+  "contributors": ["Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)", "Jonathan Puckey <jonathan@puckey.studio> (http://studiomoniker.com)"],
   "main": "dist/paper-full.js",
   "types": "dist/paper.d.ts",
   "scripts": {
@@ -24,14 +21,7 @@
     "jshint": "gulp jshint",
     "test": "gulp test"
   },
-  "files": [
-    "AUTHORS.md",
-    "CHANGELOG.md",
-    "dist/",
-    "examples/",
-    "LICENSE.txt",
-    "README.md"
-  ],
+  "files": ["AUTHORS.md", "CHANGELOG.md", "dist/", "examples/", "LICENSE.txt", "README.md"],
   "engines": {
     "node": ">=8.0.0"
   },
@@ -86,21 +76,5 @@
     "straps": "^3.0.1",
     "typescript": "^3.1.6"
   },
-  "keywords": [
-    "vector",
-    "graphic",
-    "graphics",
-    "2d",
-    "geometry",
-    "bezier",
-    "curve",
-    "curves",
-    "path",
-    "paths",
-    "canvas",
-    "svg",
-    "paper",
-    "paper.js",
-    "paperjs"
-  ]
+  "keywords": ["vector", "graphic", "graphics", "2d", "geometry", "bezier", "curve", "curves", "path", "paths", "canvas", "svg", "paper", "paper.js", "paperjs"]
 }
diff --git a/packages/paper-jsdom b/packages/paper-jsdom
index 59f1653c..33c25749 160000
--- a/packages/paper-jsdom
+++ b/packages/paper-jsdom
@@ -1 +1 @@
-Subproject commit 59f1653c0e24fc69974b636feb2964ac7bc9c9a7
+Subproject commit 33c25749460be037bf9afdb80700205c3cfd0942
diff --git a/packages/paper-jsdom-canvas b/packages/paper-jsdom-canvas
index baf33b9a..317d44cf 160000
--- a/packages/paper-jsdom-canvas
+++ b/packages/paper-jsdom-canvas
@@ -1 +1 @@
-Subproject commit baf33b9a7d95e839d068337929bdc05694b3ab0a
+Subproject commit 317d44cfa658b2ec242cbb2f54572e2e1b58a3d2
diff --git a/src/options.js b/src/options.js
index 814a2705..ee000df2 100644
--- a/src/options.js
+++ b/src/options.js
@@ -17,7 +17,7 @@
 // The paper.js version.
 // NOTE: Adjust value here before calling `gulp publish`, which then updates and
 // publishes the various JSON package files automatically.
-var version = '0.12.6';
+var version = '0.12.7';
 
 // If this file is loaded in the browser, we're in load.js mode.
 var load = typeof window === 'object';